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	····{
9514	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9515	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9516	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9517	Assert. Null( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #1") ;
9518	Assert. Null( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation shouldn't have a TypeColumn #2") ;
9519	····}
9520	····[Test]
9521	····public void HasTypeCode()
9522	····{
9523	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9524	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9525	····}
9526	}
9527
9528
9529	[TestFixture]
9530	public class MappingTestAgrDir1OwnpabsOthpabsNoTblGuid
9531	{
9532	····PersistenceManager pm;
9533	····NDOMapping mapping;
9534	····Class ownClass;
9535	····Class otherClass;
9536	····Class ownDerivedClass;
9537	····Class otherDerivedClass;
9538	····[SetUp]
9539	····public void Setup()
9540	····{
9541	········this.pm = PmFactory.NewPersistenceManager();
9542	········this.mapping = pm.NDOMapping;
9543	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidLeftBase" );
9544	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidRightBase" );
9545	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidLeftDerived" );
9546	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidRightDerived" );
9547	····}
9548	····[Test]
9549	····public void HasMappingTable()
9550	····{
9551	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
9552	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
9553	····}
9554	····[Test]
9555	····public void HasTypeColumn()
9556	····{
9557	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
9558	····}
9559	····[Test]
9560	····public void HasTypeCode()
9561	····{
9562	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9563	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9564	····}
9565	}
9566
9567
9568	[TestFixture]
9569	public class MappingTestAgrDir1OwnpabsOthpabsTblGuid
9570	{
9571	····PersistenceManager pm;
9572	····NDOMapping mapping;
9573	····Class ownClass;
9574	····Class otherClass;
9575	····Class ownDerivedClass;
9576	····Class otherDerivedClass;
9577	····[SetUp]
9578	····public void Setup()
9579	····{
9580	········this.pm = PmFactory.NewPersistenceManager();
9581	········this.mapping = pm.NDOMapping;
9582	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidLeftBase" );
9583	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidRightBase" );
9584	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidLeftDerived" );
9585	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidRightDerived" );
9586	····}
9587	····[Test]
9588	····public void HasMappingTable()
9589	····{
9590	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9591	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
9592	····}
9593	····[Test]
9594	····public void HasTypeColumn()
9595	····{
9596	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
9597	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
9598	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9599	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
9600	····}
9601	····[Test]
9602	····public void HasTypeCode()
9603	····{
9604	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9605	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9606	····}
9607	}
9608
9609
9610	[TestFixture]
9611	public class MappingTestAgrBi11OwnpabsOthpabsNoTblGuid
9612	{
9613	····PersistenceManager pm;
9614	····NDOMapping mapping;
9615	····Class ownClass;
9616	····Class otherClass;
9617	····Class ownDerivedClass;
9618	····Class otherDerivedClass;
9619	····[SetUp]
9620	····public void Setup()
9621	····{
9622	········this.pm = PmFactory.NewPersistenceManager();
9623	········this.mapping = pm.NDOMapping;
9624	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidLeftBase" );
9625	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidRightBase" );
9626	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidLeftDerived" );
9627	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidRightDerived" );
9628	····}
9629	····[Test]
9630	····public void HasMappingTable()
9631	····{
9632	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
9633	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
9634	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
9635	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
9636	····}
9637	····[Test]
9638	····public void HasTypeColumn()
9639	····{
9640	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
9641	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
9642	····}
9643	····[Test]
9644	····public void HasTypeCode()
9645	····{
9646	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9647	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9648	····}
9649	}
9650
9651
9652	[TestFixture]
9653	public class MappingTestAgrBi11OwnpabsOthpabsTblGuid
9654	{
9655	····PersistenceManager pm;
9656	····NDOMapping mapping;
9657	····Class ownClass;
9658	····Class otherClass;
9659	····Class ownDerivedClass;
9660	····Class otherDerivedClass;
9661	····[SetUp]
9662	····public void Setup()
9663	····{
9664	········this.pm = PmFactory.NewPersistenceManager();
9665	········this.mapping = pm.NDOMapping;
9666	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidLeftBase" );
9667	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidRightBase" );
9668	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidLeftDerived" );
9669	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidRightDerived" );
9670	····}
9671	····[Test]
9672	····public void HasMappingTable()
9673	····{
9674	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9675	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
9676	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9677	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9678	····}
9679	····[Test]
9680	····public void HasTypeColumn()
9681	····{
9682	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
9683	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
9684	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9685	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
9686	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9687	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9688	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
9689	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
9690	····}
9691	····[Test]
9692	····public void HasTypeCode()
9693	····{
9694	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9695	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9696	····}
9697	}
9698
9699
9700	[TestFixture]
9701	public class MappingTestAgrDirnOwnpabsOthpabsTblGuid
9702	{
9703	····PersistenceManager pm;
9704	····NDOMapping mapping;
9705	····Class ownClass;
9706	····Class otherClass;
9707	····Class ownDerivedClass;
9708	····Class otherDerivedClass;
9709	····[SetUp]
9710	····public void Setup()
9711	····{
9712	········this.pm = PmFactory.NewPersistenceManager();
9713	········this.mapping = pm.NDOMapping;
9714	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidLeftBase" );
9715	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidRightBase" );
9716	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidLeftDerived" );
9717	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidRightDerived" );
9718	····}
9719	····[Test]
9720	····public void HasMappingTable()
9721	····{
9722	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9723	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
9724	····}
9725	····[Test]
9726	····public void HasTypeColumn()
9727	····{
9728	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
9729	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
9730	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9731	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
9732	····}
9733	····[Test]
9734	····public void HasTypeCode()
9735	····{
9736	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9737	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9738	····}
9739	}
9740
9741
9742	[TestFixture]
9743	public class MappingTestAgrBin1OwnpabsOthpabsTblGuid
9744	{
9745	····PersistenceManager pm;
9746	····NDOMapping mapping;
9747	····Class ownClass;
9748	····Class otherClass;
9749	····Class ownDerivedClass;
9750	····Class otherDerivedClass;
9751	····[SetUp]
9752	····public void Setup()
9753	····{
9754	········this.pm = PmFactory.NewPersistenceManager();
9755	········this.mapping = pm.NDOMapping;
9756	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidLeftBase" );
9757	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidRightBase" );
9758	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidLeftDerived" );
9759	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidRightDerived" );
9760	····}
9761	····[Test]
9762	····public void HasMappingTable()
9763	····{
9764	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9765	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
9766	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9767	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9768	····}
9769	····[Test]
9770	····public void HasTypeColumn()
9771	····{
9772	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
9773	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
9774	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9775	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
9776	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9777	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9778	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
9779	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
9780	····}
9781	····[Test]
9782	····public void HasTypeCode()
9783	····{
9784	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9785	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9786	····}
9787	}
9788
9789
9790	[TestFixture]
9791	public class MappingTestAgrBi1nOwnpabsOthpabsTblGuid
9792	{
9793	····PersistenceManager pm;
9794	····NDOMapping mapping;
9795	····Class ownClass;
9796	····Class otherClass;
9797	····Class ownDerivedClass;
9798	····Class otherDerivedClass;
9799	····[SetUp]
9800	····public void Setup()
9801	····{
9802	········this.pm = PmFactory.NewPersistenceManager();
9803	········this.mapping = pm.NDOMapping;
9804	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidLeftBase" );
9805	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidRightBase" );
9806	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidLeftDerived" );
9807	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidRightDerived" );
9808	····}
9809	····[Test]
9810	····public void HasMappingTable()
9811	····{
9812	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9813	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
9814	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9815	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9816	····}
9817	····[Test]
9818	····public void HasTypeColumn()
9819	····{
9820	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
9821	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
9822	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9823	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
9824	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9825	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9826	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
9827	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
9828	····}
9829	····[Test]
9830	····public void HasTypeCode()
9831	····{
9832	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9833	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9834	····}
9835	}
9836
9837
9838	[TestFixture]
9839	public class MappingTestAgrBinnOwnpabsOthpabsTblGuid
9840	{
9841	····PersistenceManager pm;
9842	····NDOMapping mapping;
9843	····Class ownClass;
9844	····Class otherClass;
9845	····Class ownDerivedClass;
9846	····Class otherDerivedClass;
9847	····[SetUp]
9848	····public void Setup()
9849	····{
9850	········this.pm = PmFactory.NewPersistenceManager();
9851	········this.mapping = pm.NDOMapping;
9852	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidLeftBase" );
9853	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidRightBase" );
9854	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidLeftDerived" );
9855	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidRightDerived" );
9856	····}
9857	····[Test]
9858	····public void HasMappingTable()
9859	····{
9860	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9861	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
9862	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
9863	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
9864	····}
9865	····[Test]
9866	····public void HasTypeColumn()
9867	····{
9868	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
9869	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
9870	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9871	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
9872	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
9873	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
9874	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
9875	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
9876	····}
9877	····[Test]
9878	····public void HasTypeCode()
9879	····{
9880	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9881	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9882	····}
9883	}
9884
9885
9886	[TestFixture]
9887	public class MappingTestCmpDir1OwnpabsOthpabsNoTblGuid
9888	{
9889	····PersistenceManager pm;
9890	····NDOMapping mapping;
9891	····Class ownClass;
9892	····Class otherClass;
9893	····Class ownDerivedClass;
9894	····Class otherDerivedClass;
9895	····[SetUp]
9896	····public void Setup()
9897	····{
9898	········this.pm = PmFactory.NewPersistenceManager();
9899	········this.mapping = pm.NDOMapping;
9900	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidLeftBase" );
9901	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidRightBase" );
9902	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidLeftDerived" );
9903	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidRightDerived" );
9904	····}
9905	····[Test]
9906	····public void HasMappingTable()
9907	····{
9908	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
9909	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
9910	····}
9911	····[Test]
9912	····public void HasTypeColumn()
9913	····{
9914	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
9915	····}
9916	····[Test]
9917	····public void HasTypeCode()
9918	····{
9919	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9920	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9921	····}
9922	}
9923
9924
9925	[TestFixture]
9926	public class MappingTestCmpDir1OwnpabsOthpabsTblGuid
9927	{
9928	····PersistenceManager pm;
9929	····NDOMapping mapping;
9930	····Class ownClass;
9931	····Class otherClass;
9932	····Class ownDerivedClass;
9933	····Class otherDerivedClass;
9934	····[SetUp]
9935	····public void Setup()
9936	····{
9937	········this.pm = PmFactory.NewPersistenceManager();
9938	········this.mapping = pm.NDOMapping;
9939	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidLeftBase" );
9940	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidRightBase" );
9941	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidLeftDerived" );
9942	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidRightDerived" );
9943	····}
9944	····[Test]
9945	····public void HasMappingTable()
9946	····{
9947	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
9948	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
9949	····}
9950	····[Test]
9951	····public void HasTypeColumn()
9952	····{
9953	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
9954	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
9955	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
9956	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
9957	····}
9958	····[Test]
9959	····public void HasTypeCode()
9960	····{
9961	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9962	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9963	····}
9964	}
9965
9966
9967	[TestFixture]
9968	public class MappingTestCmpBi11OwnpabsOthpabsNoTblGuid
9969	{
9970	····PersistenceManager pm;
9971	····NDOMapping mapping;
9972	····Class ownClass;
9973	····Class otherClass;
9974	····Class ownDerivedClass;
9975	····Class otherDerivedClass;
9976	····[SetUp]
9977	····public void Setup()
9978	····{
9979	········this.pm = PmFactory.NewPersistenceManager();
9980	········this.mapping = pm.NDOMapping;
9981	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidLeftBase" );
9982	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidRightBase" );
9983	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidLeftDerived" );
9984	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidRightDerived" );
9985	····}
9986	····[Test]
9987	····public void HasMappingTable()
9988	····{
9989	Assert. Null( ownClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #5") ;
9990	Assert. Null( ownDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #6") ;
9991	Assert. Null( otherClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #7") ;
9992	Assert. Null( otherDerivedClass. Relations. First( ) . MappingTable, "Relation shouldn't have a MappingTable #8") ;
9993	····}
9994	····[Test]
9995	····public void HasTypeColumn()
9996	····{
9997	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #9") ;
9998	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #10") ;
9999	····}
10000	····[Test]
10001	····public void HasTypeCode()
10002	····{
10003	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10004	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10005	····}
10006	}
10007
10008
10009	[TestFixture]
10010	public class MappingTestCmpBi11OwnpabsOthpabsTblGuid
10011	{
10012	····PersistenceManager pm;
10013	····NDOMapping mapping;
10014	····Class ownClass;
10015	····Class otherClass;
10016	····Class ownDerivedClass;
10017	····Class otherDerivedClass;
10018	····[SetUp]
10019	····public void Setup()
10020	····{
10021	········this.pm = PmFactory.NewPersistenceManager();
10022	········this.mapping = pm.NDOMapping;
10023	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidLeftBase" );
10024	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidRightBase" );
10025	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidLeftDerived" );
10026	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidRightDerived" );
10027	····}
10028	····[Test]
10029	····public void HasMappingTable()
10030	····{
10031	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
10032	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
10033	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
10034	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
10035	····}
10036	····[Test]
10037	····public void HasTypeColumn()
10038	····{
10039	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
10040	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
10041	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
10042	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
10043	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
10044	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
10045	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
10046	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
10047	····}
10048	····[Test]
10049	····public void HasTypeCode()
10050	····{
10051	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10052	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10053	····}
10054	}
10055
10056
10057	[TestFixture]
10058	public class MappingTestCmpDirnOwnpabsOthpabsTblGuid
10059	{
10060	····PersistenceManager pm;
10061	····NDOMapping mapping;
10062	····Class ownClass;
10063	····Class otherClass;
10064	····Class ownDerivedClass;
10065	····Class otherDerivedClass;
10066	····[SetUp]
10067	····public void Setup()
10068	····{
10069	········this.pm = PmFactory.NewPersistenceManager();
10070	········this.mapping = pm.NDOMapping;
10071	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidLeftBase" );
10072	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidRightBase" );
10073	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidLeftDerived" );
10074	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidRightDerived" );
10075	····}
10076	····[Test]
10077	····public void HasMappingTable()
10078	····{
10079	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
10080	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
10081	····}
10082	····[Test]
10083	····public void HasTypeColumn()
10084	····{
10085	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
10086	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
10087	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
10088	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
10089	····}
10090	····[Test]
10091	····public void HasTypeCode()
10092	····{
10093	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10094	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10095	····}
10096	}
10097
10098
10099	[TestFixture]
10100	public class MappingTestCmpBin1OwnpabsOthpabsTblGuid
10101	{
10102	····PersistenceManager pm;
10103	····NDOMapping mapping;
10104	····Class ownClass;
10105	····Class otherClass;
10106	····Class ownDerivedClass;
10107	····Class otherDerivedClass;
10108	····[SetUp]
10109	····public void Setup()
10110	····{
10111	········this.pm = PmFactory.NewPersistenceManager();
10112	········this.mapping = pm.NDOMapping;
10113	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidLeftBase" );
10114	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidRightBase" );
10115	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidLeftDerived" );
10116	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidRightDerived" );
10117	····}
10118	····[Test]
10119	····public void HasMappingTable()
10120	····{
10121	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
10122	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
10123	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
10124	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
10125	····}
10126	····[Test]
10127	····public void HasTypeColumn()
10128	····{
10129	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
10130	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
10131	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
10132	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
10133	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
10134	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
10135	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
10136	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
10137	····}
10138	····[Test]
10139	····public void HasTypeCode()
10140	····{
10141	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10142	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10143	····}
10144	}
10145
10146
10147	[TestFixture]
10148	public class MappingTestCmpBi1nOwnpabsOthpabsTblGuid
10149	{
10150	····PersistenceManager pm;
10151	····NDOMapping mapping;
10152	····Class ownClass;
10153	····Class otherClass;
10154	····Class ownDerivedClass;
10155	····Class otherDerivedClass;
10156	····[SetUp]
10157	····public void Setup()
10158	····{
10159	········this.pm = PmFactory.NewPersistenceManager();
10160	········this.mapping = pm.NDOMapping;
10161	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidLeftBase" );
10162	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidRightBase" );
10163	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidLeftDerived" );
10164	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidRightDerived" );
10165	····}
10166	····[Test]
10167	····public void HasMappingTable()
10168	····{
10169	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
10170	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
10171	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
10172	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
10173	····}
10174	····[Test]
10175	····public void HasTypeColumn()
10176	····{
10177	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
10178	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
10179	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
10180	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
10181	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
10182	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
10183	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
10184	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
10185	····}
10186	····[Test]
10187	····public void HasTypeCode()
10188	····{
10189	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10190	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10191	····}
10192	}
10193
10194
10195	[TestFixture]
10196	public class MappingTestCmpBinnOwnpabsOthpabsTblGuid
10197	{
10198	····PersistenceManager pm;
10199	····NDOMapping mapping;
10200	····Class ownClass;
10201	····Class otherClass;
10202	····Class ownDerivedClass;
10203	····Class otherDerivedClass;
10204	····[SetUp]
10205	····public void Setup()
10206	····{
10207	········this.pm = PmFactory.NewPersistenceManager();
10208	········this.mapping = pm.NDOMapping;
10209	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidLeftBase" );
10210	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidRightBase" );
10211	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidLeftDerived" );
10212	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidRightDerived" );
10213	····}
10214	····[Test]
10215	····public void HasMappingTable()
10216	····{
10217	Assert. NotNull( ownClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #1") ;
10218	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #2") ;
10219	Assert. NotNull( otherClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #3") ;
10220	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable, "Relation should have a MappingTable #4") ;
10221	····}
10222	····[Test]
10223	····public void HasTypeColumn()
10224	····{
10225	Assert. NotNull( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #1") ;
10226	Assert. NotNull( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #2") ;
10227	Assert. NotNull( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #3") ;
10228	Assert. NotNull( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #4") ;
10229	Assert. NotNull( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #5") ;
10230	Assert. NotNull( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, "Relation should have a TypeColumn #6") ;
10231	Assert. NotNull( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #7") ;
10232	Assert. NotNull( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, "Relation should have a TypeColumn #8") ;
10233	····}
10234	····[Test]
10235	····public void HasTypeCode()
10236	····{
10237	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10238	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10239	····}
10240	}
10241
10242
10243
10244	}
10245

New Commit (6d63e12)

1	//
2	// Copyright (c) 2002-2019 Mirko Matytschak
3	// (www.netdataobjects.de)
4	//
5	// Author: Mirko Matytschak
6	//
7	// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
8	// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
9	// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
10	// Software, and to permit persons to whom the Software is furnished to do so, subject to the following
11	// conditions:
12
13	// The above copyright notice and this permission notice shall be included in all copies or substantial portions
14	// of the Software.
15	//
16	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
17	// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18	// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
19	// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20	// DEALINGS IN THE SOFTWARE.
21
22
23	using System;
24	using System.Linq;
25	using System.Diagnostics;
26	using System.Collections;
27	using System.Collections.Generic;
28	using NDO;
29	using NDO.Mapping;
30	using NUnit.Framework;
31	using NdoUnitTests;
32
33	namespace MappingUnitTests
34	{
35
36	public class PmFactory
37	{
38	····static PersistenceManager pm;
39	····public static PersistenceManager NewPersistenceManager()
40	····{
41	········if (pm == null)
42	········{
43	pm = new PersistenceManager( @"C:\Projekte\NDO5\UnitTestGenerator\TestGenerator\bin\UnitTests\bin\Debug\NDOMapping. xml") ;
44	········}
45	········else
46	········{
47	············pm.UnloadCache();
48	········}
49	········return pm;
50	····}
51	}
52
53
54	[TestFixture]
55	public class MappingTestAgrDir1NoTblAuto : NDOTest
56	{
57	····PersistenceManager pm;
58	····NDOMapping mapping;
59	····Class ownClass;
60	····Class otherClass;
61	····[SetUp]
62	····public void Setup()
63	····{
64	········this.pm = PmFactory.NewPersistenceManager();
65	········this.mapping = pm.NDOMapping;
66	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblAutoLeft" );
67	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblAutoRight" );
68	····}
69	····[Test]
70	····public void HasMappingTable()
71	····{
72	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
73	····}
74	····[Test]
75	····public void HasTypeColumn()
76	····{
77	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
78	····}
79	····[Test]
80	····public void HasTypeCode()
81	····{
82	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
83	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
84	····}
85	}
86
87
88	[TestFixture]
89	public class MappingTestAgrDir1TblAuto : NDOTest
90	{
91	····PersistenceManager pm;
92	····NDOMapping mapping;
93	····Class ownClass;
94	····Class otherClass;
95	····[SetUp]
96	····public void Setup()
97	····{
98	········this.pm = PmFactory.NewPersistenceManager();
99	········this.mapping = pm.NDOMapping;
100	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblAutoLeft" );
101	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblAutoRight" );
102	····}
103	····[Test]
104	····public void HasMappingTable()
105	····{
106	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
107	····}
108	····[Test]
109	····public void HasTypeColumn()
110	····{
111	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
112	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
113	····}
114	····[Test]
115	····public void HasTypeCode()
116	····{
117	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
118	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
119	····}
120	}
121
122
123	[TestFixture]
124	public class MappingTestAgrBi11NoTblAuto : NDOTest
125	{
126	····PersistenceManager pm;
127	····NDOMapping mapping;
128	····Class ownClass;
129	····Class otherClass;
130	····[SetUp]
131	····public void Setup()
132	····{
133	········this.pm = PmFactory.NewPersistenceManager();
134	········this.mapping = pm.NDOMapping;
135	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblAutoLeft" );
136	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblAutoRight" );
137	····}
138	····[Test]
139	····public void HasMappingTable()
140	····{
141	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
142	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
143	····}
144	····[Test]
145	····public void HasTypeColumn()
146	····{
147	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
148	····}
149	····[Test]
150	····public void HasTypeCode()
151	····{
152	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
153	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
154	····}
155	}
156
157
158	[TestFixture]
159	public class MappingTestAgrBi11TblAuto : NDOTest
160	{
161	····PersistenceManager pm;
162	····NDOMapping mapping;
163	····Class ownClass;
164	····Class otherClass;
165	····[SetUp]
166	····public void Setup()
167	····{
168	········this.pm = PmFactory.NewPersistenceManager();
169	········this.mapping = pm.NDOMapping;
170	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblAutoLeft" );
171	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblAutoRight" );
172	····}
173	····[Test]
174	····public void HasMappingTable()
175	····{
176	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
177	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
178	····}
179	····[Test]
180	····public void HasTypeColumn()
181	····{
182	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
183	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
184	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
185	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
186	····}
187	····[Test]
188	····public void HasTypeCode()
189	····{
190	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
191	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
192	····}
193	}
194
195
196	[TestFixture]
197	public class MappingTestAgrDirnNoTblAuto : NDOTest
198	{
199	····PersistenceManager pm;
200	····NDOMapping mapping;
201	····Class ownClass;
202	····Class otherClass;
203	····[SetUp]
204	····public void Setup()
205	····{
206	········this.pm = PmFactory.NewPersistenceManager();
207	········this.mapping = pm.NDOMapping;
208	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblAutoLeft" );
209	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblAutoRight" );
210	····}
211	····[Test]
212	····public void HasMappingTable()
213	····{
214	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
215	····}
216	····[Test]
217	····public void HasTypeColumn()
218	····{
219	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
220	····}
221	····[Test]
222	····public void HasTypeCode()
223	····{
224	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
225	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
226	····}
227	}
228
229
230	[TestFixture]
231	public class MappingTestAgrDirnTblAuto : NDOTest
232	{
233	····PersistenceManager pm;
234	····NDOMapping mapping;
235	····Class ownClass;
236	····Class otherClass;
237	····[SetUp]
238	····public void Setup()
239	····{
240	········this.pm = PmFactory.NewPersistenceManager();
241	········this.mapping = pm.NDOMapping;
242	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblAutoLeft" );
243	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblAutoRight" );
244	····}
245	····[Test]
246	····public void HasMappingTable()
247	····{
248	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
249	····}
250	····[Test]
251	····public void HasTypeColumn()
252	····{
253	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
254	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
255	····}
256	····[Test]
257	····public void HasTypeCode()
258	····{
259	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
260	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
261	····}
262	}
263
264
265	[TestFixture]
266	public class MappingTestAgrBin1NoTblAuto : NDOTest
267	{
268	····PersistenceManager pm;
269	····NDOMapping mapping;
270	····Class ownClass;
271	····Class otherClass;
272	····[SetUp]
273	····public void Setup()
274	····{
275	········this.pm = PmFactory.NewPersistenceManager();
276	········this.mapping = pm.NDOMapping;
277	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblAutoLeft" );
278	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblAutoRight" );
279	····}
280	····[Test]
281	····public void HasMappingTable()
282	····{
283	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
284	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
285	····}
286	····[Test]
287	····public void HasTypeColumn()
288	····{
289	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
290	····}
291	····[Test]
292	····public void HasTypeCode()
293	····{
294	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
295	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
296	····}
297	}
298
299
300	[TestFixture]
301	public class MappingTestAgrBin1TblAuto : NDOTest
302	{
303	····PersistenceManager pm;
304	····NDOMapping mapping;
305	····Class ownClass;
306	····Class otherClass;
307	····[SetUp]
308	····public void Setup()
309	····{
310	········this.pm = PmFactory.NewPersistenceManager();
311	········this.mapping = pm.NDOMapping;
312	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblAutoLeft" );
313	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblAutoRight" );
314	····}
315	····[Test]
316	····public void HasMappingTable()
317	····{
318	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
319	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
320	····}
321	····[Test]
322	····public void HasTypeColumn()
323	····{
324	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
325	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
326	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
327	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
328	····}
329	····[Test]
330	····public void HasTypeCode()
331	····{
332	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
333	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
334	····}
335	}
336
337
338	[TestFixture]
339	public class MappingTestAgrBi1nNoTblAuto : NDOTest
340	{
341	····PersistenceManager pm;
342	····NDOMapping mapping;
343	····Class ownClass;
344	····Class otherClass;
345	····[SetUp]
346	····public void Setup()
347	····{
348	········this.pm = PmFactory.NewPersistenceManager();
349	········this.mapping = pm.NDOMapping;
350	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblAutoLeft" );
351	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblAutoRight" );
352	····}
353	····[Test]
354	····public void HasMappingTable()
355	····{
356	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
357	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
358	····}
359	····[Test]
360	····public void HasTypeColumn()
361	····{
362	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
363	····}
364	····[Test]
365	····public void HasTypeCode()
366	····{
367	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
368	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
369	····}
370	}
371
372
373	[TestFixture]
374	public class MappingTestAgrBi1nTblAuto : NDOTest
375	{
376	····PersistenceManager pm;
377	····NDOMapping mapping;
378	····Class ownClass;
379	····Class otherClass;
380	····[SetUp]
381	····public void Setup()
382	····{
383	········this.pm = PmFactory.NewPersistenceManager();
384	········this.mapping = pm.NDOMapping;
385	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblAutoLeft" );
386	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblAutoRight" );
387	····}
388	····[Test]
389	····public void HasMappingTable()
390	····{
391	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
392	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
393	····}
394	····[Test]
395	····public void HasTypeColumn()
396	····{
397	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
398	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
399	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
400	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
401	····}
402	····[Test]
403	····public void HasTypeCode()
404	····{
405	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
406	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
407	····}
408	}
409
410
411	[TestFixture]
412	public class MappingTestAgrBinnTblAuto : NDOTest
413	{
414	····PersistenceManager pm;
415	····NDOMapping mapping;
416	····Class ownClass;
417	····Class otherClass;
418	····[SetUp]
419	····public void Setup()
420	····{
421	········this.pm = PmFactory.NewPersistenceManager();
422	········this.mapping = pm.NDOMapping;
423	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblAutoLeft" );
424	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblAutoRight" );
425	····}
426	····[Test]
427	····public void HasMappingTable()
428	····{
429	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
430	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
431	····}
432	····[Test]
433	····public void HasTypeColumn()
434	····{
435	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
436	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
437	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
438	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
439	····}
440	····[Test]
441	····public void HasTypeCode()
442	····{
443	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
444	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
445	····}
446	}
447
448
449	[TestFixture]
450	public class MappingTestCmpDir1NoTblAuto : NDOTest
451	{
452	····PersistenceManager pm;
453	····NDOMapping mapping;
454	····Class ownClass;
455	····Class otherClass;
456	····[SetUp]
457	····public void Setup()
458	····{
459	········this.pm = PmFactory.NewPersistenceManager();
460	········this.mapping = pm.NDOMapping;
461	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblAutoLeft" );
462	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblAutoRight" );
463	····}
464	····[Test]
465	····public void HasMappingTable()
466	····{
467	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
468	····}
469	····[Test]
470	····public void HasTypeColumn()
471	····{
472	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
473	····}
474	····[Test]
475	····public void HasTypeCode()
476	····{
477	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
478	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
479	····}
480	}
481
482
483	[TestFixture]
484	public class MappingTestCmpDir1TblAuto : NDOTest
485	{
486	····PersistenceManager pm;
487	····NDOMapping mapping;
488	····Class ownClass;
489	····Class otherClass;
490	····[SetUp]
491	····public void Setup()
492	····{
493	········this.pm = PmFactory.NewPersistenceManager();
494	········this.mapping = pm.NDOMapping;
495	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblAutoLeft" );
496	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblAutoRight" );
497	····}
498	····[Test]
499	····public void HasMappingTable()
500	····{
501	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
502	····}
503	····[Test]
504	····public void HasTypeColumn()
505	····{
506	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
507	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
508	····}
509	····[Test]
510	····public void HasTypeCode()
511	····{
512	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
513	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
514	····}
515	}
516
517
518	[TestFixture]
519	public class MappingTestCmpBi11NoTblAuto : NDOTest
520	{
521	····PersistenceManager pm;
522	····NDOMapping mapping;
523	····Class ownClass;
524	····Class otherClass;
525	····[SetUp]
526	····public void Setup()
527	····{
528	········this.pm = PmFactory.NewPersistenceManager();
529	········this.mapping = pm.NDOMapping;
530	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblAutoLeft" );
531	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblAutoRight" );
532	····}
533	····[Test]
534	····public void HasMappingTable()
535	····{
536	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
537	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
538	····}
539	····[Test]
540	····public void HasTypeColumn()
541	····{
542	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
543	····}
544	····[Test]
545	····public void HasTypeCode()
546	····{
547	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
548	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
549	····}
550	}
551
552
553	[TestFixture]
554	public class MappingTestCmpBi11TblAuto : NDOTest
555	{
556	····PersistenceManager pm;
557	····NDOMapping mapping;
558	····Class ownClass;
559	····Class otherClass;
560	····[SetUp]
561	····public void Setup()
562	····{
563	········this.pm = PmFactory.NewPersistenceManager();
564	········this.mapping = pm.NDOMapping;
565	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblAutoLeft" );
566	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblAutoRight" );
567	····}
568	····[Test]
569	····public void HasMappingTable()
570	····{
571	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
572	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
573	····}
574	····[Test]
575	····public void HasTypeColumn()
576	····{
577	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
578	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
579	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
580	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
581	····}
582	····[Test]
583	····public void HasTypeCode()
584	····{
585	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
586	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
587	····}
588	}
589
590
591	[TestFixture]
592	public class MappingTestCmpDirnNoTblAuto : NDOTest
593	{
594	····PersistenceManager pm;
595	····NDOMapping mapping;
596	····Class ownClass;
597	····Class otherClass;
598	····[SetUp]
599	····public void Setup()
600	····{
601	········this.pm = PmFactory.NewPersistenceManager();
602	········this.mapping = pm.NDOMapping;
603	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblAutoLeft" );
604	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblAutoRight" );
605	····}
606	····[Test]
607	····public void HasMappingTable()
608	····{
609	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
610	····}
611	····[Test]
612	····public void HasTypeColumn()
613	····{
614	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
615	····}
616	····[Test]
617	····public void HasTypeCode()
618	····{
619	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
620	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
621	····}
622	}
623
624
625	[TestFixture]
626	public class MappingTestCmpDirnTblAuto : NDOTest
627	{
628	····PersistenceManager pm;
629	····NDOMapping mapping;
630	····Class ownClass;
631	····Class otherClass;
632	····[SetUp]
633	····public void Setup()
634	····{
635	········this.pm = PmFactory.NewPersistenceManager();
636	········this.mapping = pm.NDOMapping;
637	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblAutoLeft" );
638	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblAutoRight" );
639	····}
640	····[Test]
641	····public void HasMappingTable()
642	····{
643	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
644	····}
645	····[Test]
646	····public void HasTypeColumn()
647	····{
648	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
649	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
650	····}
651	····[Test]
652	····public void HasTypeCode()
653	····{
654	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
655	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
656	····}
657	}
658
659
660	[TestFixture]
661	public class MappingTestCmpBin1NoTblAuto : NDOTest
662	{
663	····PersistenceManager pm;
664	····NDOMapping mapping;
665	····Class ownClass;
666	····Class otherClass;
667	····[SetUp]
668	····public void Setup()
669	····{
670	········this.pm = PmFactory.NewPersistenceManager();
671	········this.mapping = pm.NDOMapping;
672	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblAutoLeft" );
673	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblAutoRight" );
674	····}
675	····[Test]
676	····public void HasMappingTable()
677	····{
678	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
679	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
680	····}
681	····[Test]
682	····public void HasTypeColumn()
683	····{
684	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
685	····}
686	····[Test]
687	····public void HasTypeCode()
688	····{
689	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
690	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
691	····}
692	}
693
694
695	[TestFixture]
696	public class MappingTestCmpBin1TblAuto : NDOTest
697	{
698	····PersistenceManager pm;
699	····NDOMapping mapping;
700	····Class ownClass;
701	····Class otherClass;
702	····[SetUp]
703	····public void Setup()
704	····{
705	········this.pm = PmFactory.NewPersistenceManager();
706	········this.mapping = pm.NDOMapping;
707	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblAutoLeft" );
708	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblAutoRight" );
709	····}
710	····[Test]
711	····public void HasMappingTable()
712	····{
713	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
714	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
715	····}
716	····[Test]
717	····public void HasTypeColumn()
718	····{
719	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
720	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
721	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
722	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
723	····}
724	····[Test]
725	····public void HasTypeCode()
726	····{
727	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
728	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
729	····}
730	}
731
732
733	[TestFixture]
734	public class MappingTestCmpBi1nNoTblAuto : NDOTest
735	{
736	····PersistenceManager pm;
737	····NDOMapping mapping;
738	····Class ownClass;
739	····Class otherClass;
740	····[SetUp]
741	····public void Setup()
742	····{
743	········this.pm = PmFactory.NewPersistenceManager();
744	········this.mapping = pm.NDOMapping;
745	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblAutoLeft" );
746	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblAutoRight" );
747	····}
748	····[Test]
749	····public void HasMappingTable()
750	····{
751	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
752	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
753	····}
754	····[Test]
755	····public void HasTypeColumn()
756	····{
757	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
758	····}
759	····[Test]
760	····public void HasTypeCode()
761	····{
762	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
763	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
764	····}
765	}
766
767
768	[TestFixture]
769	public class MappingTestCmpBi1nTblAuto : NDOTest
770	{
771	····PersistenceManager pm;
772	····NDOMapping mapping;
773	····Class ownClass;
774	····Class otherClass;
775	····[SetUp]
776	····public void Setup()
777	····{
778	········this.pm = PmFactory.NewPersistenceManager();
779	········this.mapping = pm.NDOMapping;
780	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblAutoLeft" );
781	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblAutoRight" );
782	····}
783	····[Test]
784	····public void HasMappingTable()
785	····{
786	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
787	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
788	····}
789	····[Test]
790	····public void HasTypeColumn()
791	····{
792	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
793	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
794	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
795	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
796	····}
797	····[Test]
798	····public void HasTypeCode()
799	····{
800	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
801	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
802	····}
803	}
804
805
806	[TestFixture]
807	public class MappingTestCmpBinnTblAuto : NDOTest
808	{
809	····PersistenceManager pm;
810	····NDOMapping mapping;
811	····Class ownClass;
812	····Class otherClass;
813	····[SetUp]
814	····public void Setup()
815	····{
816	········this.pm = PmFactory.NewPersistenceManager();
817	········this.mapping = pm.NDOMapping;
818	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblAutoLeft" );
819	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblAutoRight" );
820	····}
821	····[Test]
822	····public void HasMappingTable()
823	····{
824	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
825	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
826	····}
827	····[Test]
828	····public void HasTypeColumn()
829	····{
830	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
831	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
832	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
833	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
834	····}
835	····[Test]
836	····public void HasTypeCode()
837	····{
838	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
839	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
840	····}
841	}
842
843
844	[TestFixture]
845	public class MappingTestAgrDir1OwnpconNoTblAuto : NDOTest
846	{
847	····PersistenceManager pm;
848	····NDOMapping mapping;
849	····Class ownClass;
850	····Class otherClass;
851	····Class ownDerivedClass;
852	····[SetUp]
853	····public void Setup()
854	····{
855	········this.pm = PmFactory.NewPersistenceManager();
856	········this.mapping = pm.NDOMapping;
857	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoLeftBase" );
858	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoRight" );
859	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblAutoLeftDerived" );
860	····}
861	····[Test]
862	····public void HasMappingTable()
863	····{
864	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
865	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
866	····}
867	····[Test]
868	····public void HasTypeColumn()
869	····{
870	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
871	····}
872	····[Test]
873	····public void HasTypeCode()
874	····{
875	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
876	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
877	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
878	····}
879	}
880
881
882	[TestFixture]
883	public class MappingTestAgrDir1OwnpconTblAuto : NDOTest
884	{
885	····PersistenceManager pm;
886	····NDOMapping mapping;
887	····Class ownClass;
888	····Class otherClass;
889	····Class ownDerivedClass;
890	····[SetUp]
891	····public void Setup()
892	····{
893	········this.pm = PmFactory.NewPersistenceManager();
894	········this.mapping = pm.NDOMapping;
895	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoLeftBase" );
896	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoRight" );
897	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblAutoLeftDerived" );
898	····}
899	····[Test]
900	····public void HasMappingTable()
901	····{
902	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
903	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
904	····}
905	····[Test]
906	····public void HasTypeColumn()
907	····{
908	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
909	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
910	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
911	····}
912	····[Test]
913	····public void HasTypeCode()
914	····{
915	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
916	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
917	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
918	····}
919	}
920
921
922	[TestFixture]
923	public class MappingTestAgrBi11OwnpconNoTblAuto : NDOTest
924	{
925	····PersistenceManager pm;
926	····NDOMapping mapping;
927	····Class ownClass;
928	····Class otherClass;
929	····Class ownDerivedClass;
930	····[SetUp]
931	····public void Setup()
932	····{
933	········this.pm = PmFactory.NewPersistenceManager();
934	········this.mapping = pm.NDOMapping;
935	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoLeftBase" );
936	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoRight" );
937	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblAutoLeftDerived" );
938	····}
939	····[Test]
940	····public void HasMappingTable()
941	····{
942	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
943	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
944	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
945	····}
946	····[Test]
947	····public void HasTypeColumn()
948	····{
949	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
950	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
951	····}
952	····[Test]
953	····public void HasTypeCode()
954	····{
955	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
956	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
957	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
958	····}
959	}
960
961
962	[TestFixture]
963	public class MappingTestAgrBi11OwnpconTblAuto : NDOTest
964	{
965	····PersistenceManager pm;
966	····NDOMapping mapping;
967	····Class ownClass;
968	····Class otherClass;
969	····Class ownDerivedClass;
970	····[SetUp]
971	····public void Setup()
972	····{
973	········this.pm = PmFactory.NewPersistenceManager();
974	········this.mapping = pm.NDOMapping;
975	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoLeftBase" );
976	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoRight" );
977	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblAutoLeftDerived" );
978	····}
979	····[Test]
980	····public void HasMappingTable()
981	····{
982	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
983	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
984	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
985	····}
986	····[Test]
987	····public void HasTypeColumn()
988	····{
989	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
990	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
991	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
992	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
993	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
994	····}
995	····[Test]
996	····public void HasTypeCode()
997	····{
998	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
999	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1000	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1001	····}
1002	}
1003
1004
1005	[TestFixture]
1006	public class MappingTestAgrDirnOwnpconNoTblAuto : NDOTest
1007	{
1008	····PersistenceManager pm;
1009	····NDOMapping mapping;
1010	····Class ownClass;
1011	····Class otherClass;
1012	····Class ownDerivedClass;
1013	····[SetUp]
1014	····public void Setup()
1015	····{
1016	········this.pm = PmFactory.NewPersistenceManager();
1017	········this.mapping = pm.NDOMapping;
1018	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoLeftBase" );
1019	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoRight" );
1020	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblAutoLeftDerived" );
1021	····}
1022	····[Test]
1023	····public void HasMappingTable()
1024	····{
1025	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1026	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
1027	····}
1028	····[Test]
1029	····public void HasTypeColumn()
1030	····{
1031	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1032	····}
1033	····[Test]
1034	····public void HasTypeCode()
1035	····{
1036	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1037	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1038	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1039	····}
1040	}
1041
1042
1043	[TestFixture]
1044	public class MappingTestAgrDirnOwnpconTblAuto : NDOTest
1045	{
1046	····PersistenceManager pm;
1047	····NDOMapping mapping;
1048	····Class ownClass;
1049	····Class otherClass;
1050	····Class ownDerivedClass;
1051	····[SetUp]
1052	····public void Setup()
1053	····{
1054	········this.pm = PmFactory.NewPersistenceManager();
1055	········this.mapping = pm.NDOMapping;
1056	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoLeftBase" );
1057	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoRight" );
1058	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblAutoLeftDerived" );
1059	····}
1060	····[Test]
1061	····public void HasMappingTable()
1062	····{
1063	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1064	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1065	····}
1066	····[Test]
1067	····public void HasTypeColumn()
1068	····{
1069	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1070	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1071	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1072	····}
1073	····[Test]
1074	····public void HasTypeCode()
1075	····{
1076	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1077	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1078	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1079	····}
1080	}
1081
1082
1083	[TestFixture]
1084	public class MappingTestAgrBin1OwnpconNoTblAuto : NDOTest
1085	{
1086	····PersistenceManager pm;
1087	····NDOMapping mapping;
1088	····Class ownClass;
1089	····Class otherClass;
1090	····Class ownDerivedClass;
1091	····[SetUp]
1092	····public void Setup()
1093	····{
1094	········this.pm = PmFactory.NewPersistenceManager();
1095	········this.mapping = pm.NDOMapping;
1096	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoLeftBase" );
1097	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoRight" );
1098	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblAutoLeftDerived" );
1099	····}
1100	····[Test]
1101	····public void HasMappingTable()
1102	····{
1103	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1104	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
1105	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
1106	····}
1107	····[Test]
1108	····public void HasTypeColumn()
1109	····{
1110	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1111	····}
1112	····[Test]
1113	····public void HasTypeCode()
1114	····{
1115	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1116	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1117	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1118	····}
1119	}
1120
1121
1122	[TestFixture]
1123	public class MappingTestAgrBin1OwnpconTblAuto : NDOTest
1124	{
1125	····PersistenceManager pm;
1126	····NDOMapping mapping;
1127	····Class ownClass;
1128	····Class otherClass;
1129	····Class ownDerivedClass;
1130	····[SetUp]
1131	····public void Setup()
1132	····{
1133	········this.pm = PmFactory.NewPersistenceManager();
1134	········this.mapping = pm.NDOMapping;
1135	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoLeftBase" );
1136	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoRight" );
1137	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblAutoLeftDerived" );
1138	····}
1139	····[Test]
1140	····public void HasMappingTable()
1141	····{
1142	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1143	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1144	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1145	····}
1146	····[Test]
1147	····public void HasTypeColumn()
1148	····{
1149	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1150	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1151	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
1152	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1153	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
1154	····}
1155	····[Test]
1156	····public void HasTypeCode()
1157	····{
1158	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1159	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1160	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1161	····}
1162	}
1163
1164
1165	[TestFixture]
1166	public class MappingTestAgrBi1nOwnpconTblAuto : NDOTest
1167	{
1168	····PersistenceManager pm;
1169	····NDOMapping mapping;
1170	····Class ownClass;
1171	····Class otherClass;
1172	····Class ownDerivedClass;
1173	····[SetUp]
1174	····public void Setup()
1175	····{
1176	········this.pm = PmFactory.NewPersistenceManager();
1177	········this.mapping = pm.NDOMapping;
1178	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoLeftBase" );
1179	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoRight" );
1180	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblAutoLeftDerived" );
1181	····}
1182	····[Test]
1183	····public void HasMappingTable()
1184	····{
1185	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1186	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1187	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1188	····}
1189	····[Test]
1190	····public void HasTypeColumn()
1191	····{
1192	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1193	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1194	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
1195	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1196	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
1197	····}
1198	····[Test]
1199	····public void HasTypeCode()
1200	····{
1201	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1202	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1203	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1204	····}
1205	}
1206
1207
1208	[TestFixture]
1209	public class MappingTestAgrBinnOwnpconTblAuto : NDOTest
1210	{
1211	····PersistenceManager pm;
1212	····NDOMapping mapping;
1213	····Class ownClass;
1214	····Class otherClass;
1215	····Class ownDerivedClass;
1216	····[SetUp]
1217	····public void Setup()
1218	····{
1219	········this.pm = PmFactory.NewPersistenceManager();
1220	········this.mapping = pm.NDOMapping;
1221	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoLeftBase" );
1222	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoRight" );
1223	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblAutoLeftDerived" );
1224	····}
1225	····[Test]
1226	····public void HasMappingTable()
1227	····{
1228	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1229	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1230	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1231	····}
1232	····[Test]
1233	····public void HasTypeColumn()
1234	····{
1235	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1236	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1237	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
1238	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1239	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
1240	····}
1241	····[Test]
1242	····public void HasTypeCode()
1243	····{
1244	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1245	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1246	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1247	····}
1248	}
1249
1250
1251	[TestFixture]
1252	public class MappingTestCmpDir1OwnpconNoTblAuto : NDOTest
1253	{
1254	····PersistenceManager pm;
1255	····NDOMapping mapping;
1256	····Class ownClass;
1257	····Class otherClass;
1258	····Class ownDerivedClass;
1259	····[SetUp]
1260	····public void Setup()
1261	····{
1262	········this.pm = PmFactory.NewPersistenceManager();
1263	········this.mapping = pm.NDOMapping;
1264	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoLeftBase" );
1265	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoRight" );
1266	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblAutoLeftDerived" );
1267	····}
1268	····[Test]
1269	····public void HasMappingTable()
1270	····{
1271	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1272	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
1273	····}
1274	····[Test]
1275	····public void HasTypeColumn()
1276	····{
1277	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1278	····}
1279	····[Test]
1280	····public void HasTypeCode()
1281	····{
1282	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1283	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1284	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1285	····}
1286	}
1287
1288
1289	[TestFixture]
1290	public class MappingTestCmpDir1OwnpconTblAuto : NDOTest
1291	{
1292	····PersistenceManager pm;
1293	····NDOMapping mapping;
1294	····Class ownClass;
1295	····Class otherClass;
1296	····Class ownDerivedClass;
1297	····[SetUp]
1298	····public void Setup()
1299	····{
1300	········this.pm = PmFactory.NewPersistenceManager();
1301	········this.mapping = pm.NDOMapping;
1302	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoLeftBase" );
1303	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoRight" );
1304	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblAutoLeftDerived" );
1305	····}
1306	····[Test]
1307	····public void HasMappingTable()
1308	····{
1309	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1310	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1311	····}
1312	····[Test]
1313	····public void HasTypeColumn()
1314	····{
1315	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1316	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1317	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1318	····}
1319	····[Test]
1320	····public void HasTypeCode()
1321	····{
1322	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1323	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1324	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1325	····}
1326	}
1327
1328
1329	[TestFixture]
1330	public class MappingTestCmpBi11OwnpconNoTblAuto : NDOTest
1331	{
1332	····PersistenceManager pm;
1333	····NDOMapping mapping;
1334	····Class ownClass;
1335	····Class otherClass;
1336	····Class ownDerivedClass;
1337	····[SetUp]
1338	····public void Setup()
1339	····{
1340	········this.pm = PmFactory.NewPersistenceManager();
1341	········this.mapping = pm.NDOMapping;
1342	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoLeftBase" );
1343	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoRight" );
1344	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblAutoLeftDerived" );
1345	····}
1346	····[Test]
1347	····public void HasMappingTable()
1348	····{
1349	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1350	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
1351	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
1352	····}
1353	····[Test]
1354	····public void HasTypeColumn()
1355	····{
1356	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1357	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
1358	····}
1359	····[Test]
1360	····public void HasTypeCode()
1361	····{
1362	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1363	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1364	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1365	····}
1366	}
1367
1368
1369	[TestFixture]
1370	public class MappingTestCmpBi11OwnpconTblAuto : NDOTest
1371	{
1372	····PersistenceManager pm;
1373	····NDOMapping mapping;
1374	····Class ownClass;
1375	····Class otherClass;
1376	····Class ownDerivedClass;
1377	····[SetUp]
1378	····public void Setup()
1379	····{
1380	········this.pm = PmFactory.NewPersistenceManager();
1381	········this.mapping = pm.NDOMapping;
1382	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoLeftBase" );
1383	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoRight" );
1384	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblAutoLeftDerived" );
1385	····}
1386	····[Test]
1387	····public void HasMappingTable()
1388	····{
1389	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1390	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1391	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1392	····}
1393	····[Test]
1394	····public void HasTypeColumn()
1395	····{
1396	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1397	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1398	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
1399	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1400	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
1401	····}
1402	····[Test]
1403	····public void HasTypeCode()
1404	····{
1405	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1406	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1407	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1408	····}
1409	}
1410
1411
1412	[TestFixture]
1413	public class MappingTestCmpDirnOwnpconNoTblAuto : NDOTest
1414	{
1415	····PersistenceManager pm;
1416	····NDOMapping mapping;
1417	····Class ownClass;
1418	····Class otherClass;
1419	····Class ownDerivedClass;
1420	····[SetUp]
1421	····public void Setup()
1422	····{
1423	········this.pm = PmFactory.NewPersistenceManager();
1424	········this.mapping = pm.NDOMapping;
1425	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoLeftBase" );
1426	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoRight" );
1427	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblAutoLeftDerived" );
1428	····}
1429	····[Test]
1430	····public void HasMappingTable()
1431	····{
1432	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1433	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
1434	····}
1435	····[Test]
1436	····public void HasTypeColumn()
1437	····{
1438	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1439	····}
1440	····[Test]
1441	····public void HasTypeCode()
1442	····{
1443	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1444	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1445	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1446	····}
1447	}
1448
1449
1450	[TestFixture]
1451	public class MappingTestCmpDirnOwnpconTblAuto : NDOTest
1452	{
1453	····PersistenceManager pm;
1454	····NDOMapping mapping;
1455	····Class ownClass;
1456	····Class otherClass;
1457	····Class ownDerivedClass;
1458	····[SetUp]
1459	····public void Setup()
1460	····{
1461	········this.pm = PmFactory.NewPersistenceManager();
1462	········this.mapping = pm.NDOMapping;
1463	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoLeftBase" );
1464	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoRight" );
1465	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblAutoLeftDerived" );
1466	····}
1467	····[Test]
1468	····public void HasMappingTable()
1469	····{
1470	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1471	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1472	····}
1473	····[Test]
1474	····public void HasTypeColumn()
1475	····{
1476	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1477	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1478	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1479	····}
1480	····[Test]
1481	····public void HasTypeCode()
1482	····{
1483	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1484	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1485	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1486	····}
1487	}
1488
1489
1490	[TestFixture]
1491	public class MappingTestCmpBin1OwnpconNoTblAuto : NDOTest
1492	{
1493	····PersistenceManager pm;
1494	····NDOMapping mapping;
1495	····Class ownClass;
1496	····Class otherClass;
1497	····Class ownDerivedClass;
1498	····[SetUp]
1499	····public void Setup()
1500	····{
1501	········this.pm = PmFactory.NewPersistenceManager();
1502	········this.mapping = pm.NDOMapping;
1503	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoLeftBase" );
1504	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoRight" );
1505	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblAutoLeftDerived" );
1506	····}
1507	····[Test]
1508	····public void HasMappingTable()
1509	····{
1510	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1511	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
1512	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
1513	····}
1514	····[Test]
1515	····public void HasTypeColumn()
1516	····{
1517	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1518	····}
1519	····[Test]
1520	····public void HasTypeCode()
1521	····{
1522	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1523	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1524	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1525	····}
1526	}
1527
1528
1529	[TestFixture]
1530	public class MappingTestCmpBin1OwnpconTblAuto : NDOTest
1531	{
1532	····PersistenceManager pm;
1533	····NDOMapping mapping;
1534	····Class ownClass;
1535	····Class otherClass;
1536	····Class ownDerivedClass;
1537	····[SetUp]
1538	····public void Setup()
1539	····{
1540	········this.pm = PmFactory.NewPersistenceManager();
1541	········this.mapping = pm.NDOMapping;
1542	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoLeftBase" );
1543	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoRight" );
1544	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblAutoLeftDerived" );
1545	····}
1546	····[Test]
1547	····public void HasMappingTable()
1548	····{
1549	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1550	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1551	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1552	····}
1553	····[Test]
1554	····public void HasTypeColumn()
1555	····{
1556	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1557	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1558	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
1559	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1560	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
1561	····}
1562	····[Test]
1563	····public void HasTypeCode()
1564	····{
1565	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1566	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1567	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1568	····}
1569	}
1570
1571
1572	[TestFixture]
1573	public class MappingTestCmpBi1nOwnpconTblAuto : NDOTest
1574	{
1575	····PersistenceManager pm;
1576	····NDOMapping mapping;
1577	····Class ownClass;
1578	····Class otherClass;
1579	····Class ownDerivedClass;
1580	····[SetUp]
1581	····public void Setup()
1582	····{
1583	········this.pm = PmFactory.NewPersistenceManager();
1584	········this.mapping = pm.NDOMapping;
1585	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoLeftBase" );
1586	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoRight" );
1587	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblAutoLeftDerived" );
1588	····}
1589	····[Test]
1590	····public void HasMappingTable()
1591	····{
1592	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1593	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1594	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1595	····}
1596	····[Test]
1597	····public void HasTypeColumn()
1598	····{
1599	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1600	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1601	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
1602	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1603	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
1604	····}
1605	····[Test]
1606	····public void HasTypeCode()
1607	····{
1608	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1609	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1610	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1611	····}
1612	}
1613
1614
1615	[TestFixture]
1616	public class MappingTestCmpBinnOwnpconTblAuto : NDOTest
1617	{
1618	····PersistenceManager pm;
1619	····NDOMapping mapping;
1620	····Class ownClass;
1621	····Class otherClass;
1622	····Class ownDerivedClass;
1623	····[SetUp]
1624	····public void Setup()
1625	····{
1626	········this.pm = PmFactory.NewPersistenceManager();
1627	········this.mapping = pm.NDOMapping;
1628	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoLeftBase" );
1629	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoRight" );
1630	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblAutoLeftDerived" );
1631	····}
1632	····[Test]
1633	····public void HasMappingTable()
1634	····{
1635	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1636	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
1637	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1638	····}
1639	····[Test]
1640	····public void HasTypeColumn()
1641	····{
1642	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
1643	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
1644	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
1645	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
1646	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
1647	····}
1648	····[Test]
1649	····public void HasTypeCode()
1650	····{
1651	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1652	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1653	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
1654	····}
1655	}
1656
1657
1658	[TestFixture]
1659	public class MappingTestAgrDir1OthpconNoTblAuto : NDOTest
1660	{
1661	····PersistenceManager pm;
1662	····NDOMapping mapping;
1663	····Class ownClass;
1664	····Class otherClass;
1665	····Class otherDerivedClass;
1666	····[SetUp]
1667	····public void Setup()
1668	····{
1669	········this.pm = PmFactory.NewPersistenceManager();
1670	········this.mapping = pm.NDOMapping;
1671	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoLeft" );
1672	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoRightBase" );
1673	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblAutoRightDerived" );
1674	····}
1675	····[Test]
1676	····public void HasMappingTable()
1677	····{
1678	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1679	····}
1680	····[Test]
1681	····public void HasTypeColumn()
1682	····{
1683	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
1684	····}
1685	····[Test]
1686	····public void HasTypeCode()
1687	····{
1688	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1689	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1690	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1691	····}
1692	}
1693
1694
1695	[TestFixture]
1696	public class MappingTestAgrDir1OthpconTblAuto : NDOTest
1697	{
1698	····PersistenceManager pm;
1699	····NDOMapping mapping;
1700	····Class ownClass;
1701	····Class otherClass;
1702	····Class otherDerivedClass;
1703	····[SetUp]
1704	····public void Setup()
1705	····{
1706	········this.pm = PmFactory.NewPersistenceManager();
1707	········this.mapping = pm.NDOMapping;
1708	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoLeft" );
1709	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoRightBase" );
1710	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblAutoRightDerived" );
1711	····}
1712	····[Test]
1713	····public void HasMappingTable()
1714	····{
1715	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1716	····}
1717	····[Test]
1718	····public void HasTypeColumn()
1719	····{
1720	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
1721	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1722	····}
1723	····[Test]
1724	····public void HasTypeCode()
1725	····{
1726	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1727	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1728	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1729	····}
1730	}
1731
1732
1733	[TestFixture]
1734	public class MappingTestAgrBi11OthpconNoTblAuto : NDOTest
1735	{
1736	····PersistenceManager pm;
1737	····NDOMapping mapping;
1738	····Class ownClass;
1739	····Class otherClass;
1740	····Class otherDerivedClass;
1741	····[SetUp]
1742	····public void Setup()
1743	····{
1744	········this.pm = PmFactory.NewPersistenceManager();
1745	········this.mapping = pm.NDOMapping;
1746	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoLeft" );
1747	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoRightBase" );
1748	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblAutoRightDerived" );
1749	····}
1750	····[Test]
1751	····public void HasMappingTable()
1752	····{
1753	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1754	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
1755	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
1756	····}
1757	····[Test]
1758	····public void HasTypeColumn()
1759	····{
1760	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
1761	····}
1762	····[Test]
1763	····public void HasTypeCode()
1764	····{
1765	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1766	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1767	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1768	····}
1769	}
1770
1771
1772	[TestFixture]
1773	public class MappingTestAgrBi11OthpconTblAuto : NDOTest
1774	{
1775	····PersistenceManager pm;
1776	····NDOMapping mapping;
1777	····Class ownClass;
1778	····Class otherClass;
1779	····Class otherDerivedClass;
1780	····[SetUp]
1781	····public void Setup()
1782	····{
1783	········this.pm = PmFactory.NewPersistenceManager();
1784	········this.mapping = pm.NDOMapping;
1785	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoLeft" );
1786	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoRightBase" );
1787	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblAutoRightDerived" );
1788	····}
1789	····[Test]
1790	····public void HasMappingTable()
1791	····{
1792	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1793	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1794	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
1795	····}
1796	····[Test]
1797	····public void HasTypeColumn()
1798	····{
1799	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
1800	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
1801	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
1802	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1803	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
1804	····}
1805	····[Test]
1806	····public void HasTypeCode()
1807	····{
1808	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1809	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1810	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1811	····}
1812	}
1813
1814
1815	[TestFixture]
1816	public class MappingTestAgrDirnOthpconTblAuto : NDOTest
1817	{
1818	····PersistenceManager pm;
1819	····NDOMapping mapping;
1820	····Class ownClass;
1821	····Class otherClass;
1822	····Class otherDerivedClass;
1823	····[SetUp]
1824	····public void Setup()
1825	····{
1826	········this.pm = PmFactory.NewPersistenceManager();
1827	········this.mapping = pm.NDOMapping;
1828	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoLeft" );
1829	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoRightBase" );
1830	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblAutoRightDerived" );
1831	····}
1832	····[Test]
1833	····public void HasMappingTable()
1834	····{
1835	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1836	····}
1837	····[Test]
1838	····public void HasTypeColumn()
1839	····{
1840	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
1841	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1842	····}
1843	····[Test]
1844	····public void HasTypeCode()
1845	····{
1846	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1847	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1848	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1849	····}
1850	}
1851
1852
1853	[TestFixture]
1854	public class MappingTestAgrBin1OthpconTblAuto : NDOTest
1855	{
1856	····PersistenceManager pm;
1857	····NDOMapping mapping;
1858	····Class ownClass;
1859	····Class otherClass;
1860	····Class otherDerivedClass;
1861	····[SetUp]
1862	····public void Setup()
1863	····{
1864	········this.pm = PmFactory.NewPersistenceManager();
1865	········this.mapping = pm.NDOMapping;
1866	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoLeft" );
1867	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoRightBase" );
1868	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblAutoRightDerived" );
1869	····}
1870	····[Test]
1871	····public void HasMappingTable()
1872	····{
1873	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1874	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1875	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
1876	····}
1877	····[Test]
1878	····public void HasTypeColumn()
1879	····{
1880	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
1881	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
1882	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
1883	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1884	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
1885	····}
1886	····[Test]
1887	····public void HasTypeCode()
1888	····{
1889	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1890	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1891	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1892	····}
1893	}
1894
1895
1896	[TestFixture]
1897	public class MappingTestAgrBi1nOthpconNoTblAuto : NDOTest
1898	{
1899	····PersistenceManager pm;
1900	····NDOMapping mapping;
1901	····Class ownClass;
1902	····Class otherClass;
1903	····Class otherDerivedClass;
1904	····[SetUp]
1905	····public void Setup()
1906	····{
1907	········this.pm = PmFactory.NewPersistenceManager();
1908	········this.mapping = pm.NDOMapping;
1909	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoLeft" );
1910	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoRightBase" );
1911	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblAutoRightDerived" );
1912	····}
1913	····[Test]
1914	····public void HasMappingTable()
1915	····{
1916	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
1917	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
1918	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
1919	····}
1920	····[Test]
1921	····public void HasTypeColumn()
1922	····{
1923	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
1924	····}
1925	····[Test]
1926	····public void HasTypeCode()
1927	····{
1928	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1929	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1930	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1931	····}
1932	}
1933
1934
1935	[TestFixture]
1936	public class MappingTestAgrBi1nOthpconTblAuto : NDOTest
1937	{
1938	····PersistenceManager pm;
1939	····NDOMapping mapping;
1940	····Class ownClass;
1941	····Class otherClass;
1942	····Class otherDerivedClass;
1943	····[SetUp]
1944	····public void Setup()
1945	····{
1946	········this.pm = PmFactory.NewPersistenceManager();
1947	········this.mapping = pm.NDOMapping;
1948	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoLeft" );
1949	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoRightBase" );
1950	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblAutoRightDerived" );
1951	····}
1952	····[Test]
1953	····public void HasMappingTable()
1954	····{
1955	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1956	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
1957	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
1958	····}
1959	····[Test]
1960	····public void HasTypeColumn()
1961	····{
1962	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
1963	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
1964	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
1965	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
1966	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
1967	····}
1968	····[Test]
1969	····public void HasTypeCode()
1970	····{
1971	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
1972	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
1973	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
1974	····}
1975	}
1976
1977
1978	[TestFixture]
1979	public class MappingTestAgrBinnOthpconTblAuto : NDOTest
1980	{
1981	····PersistenceManager pm;
1982	····NDOMapping mapping;
1983	····Class ownClass;
1984	····Class otherClass;
1985	····Class otherDerivedClass;
1986	····[SetUp]
1987	····public void Setup()
1988	····{
1989	········this.pm = PmFactory.NewPersistenceManager();
1990	········this.mapping = pm.NDOMapping;
1991	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoLeft" );
1992	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoRightBase" );
1993	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblAutoRightDerived" );
1994	····}
1995	····[Test]
1996	····public void HasMappingTable()
1997	····{
1998	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
1999	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2000	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2001	····}
2002	····[Test]
2003	····public void HasTypeColumn()
2004	····{
2005	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2006	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2007	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2008	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2009	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
2010	····}
2011	····[Test]
2012	····public void HasTypeCode()
2013	····{
2014	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2015	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2016	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2017	····}
2018	}
2019
2020
2021	[TestFixture]
2022	public class MappingTestCmpDir1OthpconTblAuto : NDOTest
2023	{
2024	····PersistenceManager pm;
2025	····NDOMapping mapping;
2026	····Class ownClass;
2027	····Class otherClass;
2028	····Class otherDerivedClass;
2029	····[SetUp]
2030	····public void Setup()
2031	····{
2032	········this.pm = PmFactory.NewPersistenceManager();
2033	········this.mapping = pm.NDOMapping;
2034	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoLeft" );
2035	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoRightBase" );
2036	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblAutoRightDerived" );
2037	····}
2038	····[Test]
2039	····public void HasMappingTable()
2040	····{
2041	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2042	····}
2043	····[Test]
2044	····public void HasTypeColumn()
2045	····{
2046	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2047	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2048	····}
2049	····[Test]
2050	····public void HasTypeCode()
2051	····{
2052	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2053	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2054	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2055	····}
2056	}
2057
2058
2059	[TestFixture]
2060	public class MappingTestCmpBi11OthpconTblAuto : NDOTest
2061	{
2062	····PersistenceManager pm;
2063	····NDOMapping mapping;
2064	····Class ownClass;
2065	····Class otherClass;
2066	····Class otherDerivedClass;
2067	····[SetUp]
2068	····public void Setup()
2069	····{
2070	········this.pm = PmFactory.NewPersistenceManager();
2071	········this.mapping = pm.NDOMapping;
2072	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoLeft" );
2073	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoRightBase" );
2074	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblAutoRightDerived" );
2075	····}
2076	····[Test]
2077	····public void HasMappingTable()
2078	····{
2079	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2080	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2081	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2082	····}
2083	····[Test]
2084	····public void HasTypeColumn()
2085	····{
2086	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2087	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2088	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2089	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2090	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
2091	····}
2092	····[Test]
2093	····public void HasTypeCode()
2094	····{
2095	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2096	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2097	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2098	····}
2099	}
2100
2101
2102	[TestFixture]
2103	public class MappingTestCmpDirnOthpconTblAuto : NDOTest
2104	{
2105	····PersistenceManager pm;
2106	····NDOMapping mapping;
2107	····Class ownClass;
2108	····Class otherClass;
2109	····Class otherDerivedClass;
2110	····[SetUp]
2111	····public void Setup()
2112	····{
2113	········this.pm = PmFactory.NewPersistenceManager();
2114	········this.mapping = pm.NDOMapping;
2115	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoLeft" );
2116	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoRightBase" );
2117	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblAutoRightDerived" );
2118	····}
2119	····[Test]
2120	····public void HasMappingTable()
2121	····{
2122	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2123	····}
2124	····[Test]
2125	····public void HasTypeColumn()
2126	····{
2127	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2128	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2129	····}
2130	····[Test]
2131	····public void HasTypeCode()
2132	····{
2133	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2134	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2135	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2136	····}
2137	}
2138
2139
2140	[TestFixture]
2141	public class MappingTestCmpBin1OthpconTblAuto : NDOTest
2142	{
2143	····PersistenceManager pm;
2144	····NDOMapping mapping;
2145	····Class ownClass;
2146	····Class otherClass;
2147	····Class otherDerivedClass;
2148	····[SetUp]
2149	····public void Setup()
2150	····{
2151	········this.pm = PmFactory.NewPersistenceManager();
2152	········this.mapping = pm.NDOMapping;
2153	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoLeft" );
2154	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoRightBase" );
2155	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblAutoRightDerived" );
2156	····}
2157	····[Test]
2158	····public void HasMappingTable()
2159	····{
2160	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2161	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2162	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2163	····}
2164	····[Test]
2165	····public void HasTypeColumn()
2166	····{
2167	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2168	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2169	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2170	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2171	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
2172	····}
2173	····[Test]
2174	····public void HasTypeCode()
2175	····{
2176	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2177	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2178	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2179	····}
2180	}
2181
2182
2183	[TestFixture]
2184	public class MappingTestCmpBi1nOthpconTblAuto : NDOTest
2185	{
2186	····PersistenceManager pm;
2187	····NDOMapping mapping;
2188	····Class ownClass;
2189	····Class otherClass;
2190	····Class otherDerivedClass;
2191	····[SetUp]
2192	····public void Setup()
2193	····{
2194	········this.pm = PmFactory.NewPersistenceManager();
2195	········this.mapping = pm.NDOMapping;
2196	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoLeft" );
2197	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoRightBase" );
2198	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblAutoRightDerived" );
2199	····}
2200	····[Test]
2201	····public void HasMappingTable()
2202	····{
2203	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2204	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2205	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2206	····}
2207	····[Test]
2208	····public void HasTypeColumn()
2209	····{
2210	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2211	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2212	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2213	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2214	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
2215	····}
2216	····[Test]
2217	····public void HasTypeCode()
2218	····{
2219	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2220	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2221	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2222	····}
2223	}
2224
2225
2226	[TestFixture]
2227	public class MappingTestCmpBinnOthpconTblAuto : NDOTest
2228	{
2229	····PersistenceManager pm;
2230	····NDOMapping mapping;
2231	····Class ownClass;
2232	····Class otherClass;
2233	····Class otherDerivedClass;
2234	····[SetUp]
2235	····public void Setup()
2236	····{
2237	········this.pm = PmFactory.NewPersistenceManager();
2238	········this.mapping = pm.NDOMapping;
2239	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoLeft" );
2240	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoRightBase" );
2241	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblAutoRightDerived" );
2242	····}
2243	····[Test]
2244	····public void HasMappingTable()
2245	····{
2246	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2247	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2248	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2249	····}
2250	····[Test]
2251	····public void HasTypeColumn()
2252	····{
2253	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2254	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2255	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2256	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2257	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
2258	····}
2259	····[Test]
2260	····public void HasTypeCode()
2261	····{
2262	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2263	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2264	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2265	····}
2266	}
2267
2268
2269	[TestFixture]
2270	public class MappingTestAgrDir1OwnpconOthpconNoTblAuto : NDOTest
2271	{
2272	····PersistenceManager pm;
2273	····NDOMapping mapping;
2274	····Class ownClass;
2275	····Class otherClass;
2276	····Class ownDerivedClass;
2277	····Class otherDerivedClass;
2278	····[SetUp]
2279	····public void Setup()
2280	····{
2281	········this.pm = PmFactory.NewPersistenceManager();
2282	········this.mapping = pm.NDOMapping;
2283	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoLeftBase" );
2284	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoRightBase" );
2285	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoLeftDerived" );
2286	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblAutoRightDerived" );
2287	····}
2288	····[Test]
2289	····public void HasMappingTable()
2290	····{
2291	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
2292	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
2293	····}
2294	····[Test]
2295	····public void HasTypeColumn()
2296	····{
2297	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
2298	····}
2299	····[Test]
2300	····public void HasTypeCode()
2301	····{
2302	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2303	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2304	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2305	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2306	····}
2307	}
2308
2309
2310	[TestFixture]
2311	public class MappingTestAgrDir1OwnpconOthpconTblAuto : NDOTest
2312	{
2313	····PersistenceManager pm;
2314	····NDOMapping mapping;
2315	····Class ownClass;
2316	····Class otherClass;
2317	····Class ownDerivedClass;
2318	····Class otherDerivedClass;
2319	····[SetUp]
2320	····public void Setup()
2321	····{
2322	········this.pm = PmFactory.NewPersistenceManager();
2323	········this.mapping = pm.NDOMapping;
2324	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoLeftBase" );
2325	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoRightBase" );
2326	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoLeftDerived" );
2327	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblAutoRightDerived" );
2328	····}
2329	····[Test]
2330	····public void HasMappingTable()
2331	····{
2332	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2333	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2334	····}
2335	····[Test]
2336	····public void HasTypeColumn()
2337	····{
2338	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2339	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2340	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2341	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2342	····}
2343	····[Test]
2344	····public void HasTypeCode()
2345	····{
2346	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2347	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2348	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2349	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2350	····}
2351	}
2352
2353
2354	[TestFixture]
2355	public class MappingTestAgrBi11OwnpconOthpconNoTblAuto : NDOTest
2356	{
2357	····PersistenceManager pm;
2358	····NDOMapping mapping;
2359	····Class ownClass;
2360	····Class otherClass;
2361	····Class ownDerivedClass;
2362	····Class otherDerivedClass;
2363	····[SetUp]
2364	····public void Setup()
2365	····{
2366	········this.pm = PmFactory.NewPersistenceManager();
2367	········this.mapping = pm.NDOMapping;
2368	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoLeftBase" );
2369	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoRightBase" );
2370	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoLeftDerived" );
2371	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblAutoRightDerived" );
2372	····}
2373	····[Test]
2374	····public void HasMappingTable()
2375	····{
2376	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
2377	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
2378	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
2379	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
2380	····}
2381	····[Test]
2382	····public void HasTypeColumn()
2383	····{
2384	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
2385	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
2386	····}
2387	····[Test]
2388	····public void HasTypeCode()
2389	····{
2390	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2391	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2392	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2393	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2394	····}
2395	}
2396
2397
2398	[TestFixture]
2399	public class MappingTestAgrBi11OwnpconOthpconTblAuto : NDOTest
2400	{
2401	····PersistenceManager pm;
2402	····NDOMapping mapping;
2403	····Class ownClass;
2404	····Class otherClass;
2405	····Class ownDerivedClass;
2406	····Class otherDerivedClass;
2407	····[SetUp]
2408	····public void Setup()
2409	····{
2410	········this.pm = PmFactory.NewPersistenceManager();
2411	········this.mapping = pm.NDOMapping;
2412	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoLeftBase" );
2413	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoRightBase" );
2414	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoLeftDerived" );
2415	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblAutoRightDerived" );
2416	····}
2417	····[Test]
2418	····public void HasMappingTable()
2419	····{
2420	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2421	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2422	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2423	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2424	····}
2425	····[Test]
2426	····public void HasTypeColumn()
2427	····{
2428	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2429	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2430	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2431	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2432	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2433	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2434	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
2435	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
2436	····}
2437	····[Test]
2438	····public void HasTypeCode()
2439	····{
2440	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2441	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2442	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2443	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2444	····}
2445	}
2446
2447
2448	[TestFixture]
2449	public class MappingTestAgrDirnOwnpconOthpconTblAuto : NDOTest
2450	{
2451	····PersistenceManager pm;
2452	····NDOMapping mapping;
2453	····Class ownClass;
2454	····Class otherClass;
2455	····Class ownDerivedClass;
2456	····Class otherDerivedClass;
2457	····[SetUp]
2458	····public void Setup()
2459	····{
2460	········this.pm = PmFactory.NewPersistenceManager();
2461	········this.mapping = pm.NDOMapping;
2462	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoLeftBase" );
2463	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoRightBase" );
2464	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoLeftDerived" );
2465	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblAutoRightDerived" );
2466	····}
2467	····[Test]
2468	····public void HasMappingTable()
2469	····{
2470	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2471	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2472	····}
2473	····[Test]
2474	····public void HasTypeColumn()
2475	····{
2476	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2477	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2478	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2479	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2480	····}
2481	····[Test]
2482	····public void HasTypeCode()
2483	····{
2484	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2485	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2486	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2487	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2488	····}
2489	}
2490
2491
2492	[TestFixture]
2493	public class MappingTestAgrBin1OwnpconOthpconTblAuto : NDOTest
2494	{
2495	····PersistenceManager pm;
2496	····NDOMapping mapping;
2497	····Class ownClass;
2498	····Class otherClass;
2499	····Class ownDerivedClass;
2500	····Class otherDerivedClass;
2501	····[SetUp]
2502	····public void Setup()
2503	····{
2504	········this.pm = PmFactory.NewPersistenceManager();
2505	········this.mapping = pm.NDOMapping;
2506	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoLeftBase" );
2507	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoRightBase" );
2508	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoLeftDerived" );
2509	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblAutoRightDerived" );
2510	····}
2511	····[Test]
2512	····public void HasMappingTable()
2513	····{
2514	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2515	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2516	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2517	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2518	····}
2519	····[Test]
2520	····public void HasTypeColumn()
2521	····{
2522	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2523	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2524	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2525	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2526	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2527	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2528	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
2529	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
2530	····}
2531	····[Test]
2532	····public void HasTypeCode()
2533	····{
2534	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2535	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2536	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2537	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2538	····}
2539	}
2540
2541
2542	[TestFixture]
2543	public class MappingTestAgrBi1nOwnpconOthpconTblAuto : NDOTest
2544	{
2545	····PersistenceManager pm;
2546	····NDOMapping mapping;
2547	····Class ownClass;
2548	····Class otherClass;
2549	····Class ownDerivedClass;
2550	····Class otherDerivedClass;
2551	····[SetUp]
2552	····public void Setup()
2553	····{
2554	········this.pm = PmFactory.NewPersistenceManager();
2555	········this.mapping = pm.NDOMapping;
2556	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoLeftBase" );
2557	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoRightBase" );
2558	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoLeftDerived" );
2559	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblAutoRightDerived" );
2560	····}
2561	····[Test]
2562	····public void HasMappingTable()
2563	····{
2564	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2565	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2566	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2567	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2568	····}
2569	····[Test]
2570	····public void HasTypeColumn()
2571	····{
2572	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2573	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2574	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2575	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2576	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2577	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2578	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
2579	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
2580	····}
2581	····[Test]
2582	····public void HasTypeCode()
2583	····{
2584	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2585	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2586	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2587	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2588	····}
2589	}
2590
2591
2592	[TestFixture]
2593	public class MappingTestAgrBinnOwnpconOthpconTblAuto : NDOTest
2594	{
2595	····PersistenceManager pm;
2596	····NDOMapping mapping;
2597	····Class ownClass;
2598	····Class otherClass;
2599	····Class ownDerivedClass;
2600	····Class otherDerivedClass;
2601	····[SetUp]
2602	····public void Setup()
2603	····{
2604	········this.pm = PmFactory.NewPersistenceManager();
2605	········this.mapping = pm.NDOMapping;
2606	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoLeftBase" );
2607	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoRightBase" );
2608	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoLeftDerived" );
2609	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblAutoRightDerived" );
2610	····}
2611	····[Test]
2612	····public void HasMappingTable()
2613	····{
2614	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2615	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2616	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2617	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2618	····}
2619	····[Test]
2620	····public void HasTypeColumn()
2621	····{
2622	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2623	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2624	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2625	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2626	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2627	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2628	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
2629	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
2630	····}
2631	····[Test]
2632	····public void HasTypeCode()
2633	····{
2634	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2635	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2636	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2637	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2638	····}
2639	}
2640
2641
2642	[TestFixture]
2643	public class MappingTestCmpDir1OwnpconOthpconTblAuto : NDOTest
2644	{
2645	····PersistenceManager pm;
2646	····NDOMapping mapping;
2647	····Class ownClass;
2648	····Class otherClass;
2649	····Class ownDerivedClass;
2650	····Class otherDerivedClass;
2651	····[SetUp]
2652	····public void Setup()
2653	····{
2654	········this.pm = PmFactory.NewPersistenceManager();
2655	········this.mapping = pm.NDOMapping;
2656	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoLeftBase" );
2657	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoRightBase" );
2658	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoLeftDerived" );
2659	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblAutoRightDerived" );
2660	····}
2661	····[Test]
2662	····public void HasMappingTable()
2663	····{
2664	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2665	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2666	····}
2667	····[Test]
2668	····public void HasTypeColumn()
2669	····{
2670	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2671	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2672	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2673	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2674	····}
2675	····[Test]
2676	····public void HasTypeCode()
2677	····{
2678	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2679	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2680	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2681	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2682	····}
2683	}
2684
2685
2686	[TestFixture]
2687	public class MappingTestCmpBi11OwnpconOthpconTblAuto : NDOTest
2688	{
2689	····PersistenceManager pm;
2690	····NDOMapping mapping;
2691	····Class ownClass;
2692	····Class otherClass;
2693	····Class ownDerivedClass;
2694	····Class otherDerivedClass;
2695	····[SetUp]
2696	····public void Setup()
2697	····{
2698	········this.pm = PmFactory.NewPersistenceManager();
2699	········this.mapping = pm.NDOMapping;
2700	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoLeftBase" );
2701	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoRightBase" );
2702	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoLeftDerived" );
2703	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblAutoRightDerived" );
2704	····}
2705	····[Test]
2706	····public void HasMappingTable()
2707	····{
2708	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2709	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2710	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2711	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2712	····}
2713	····[Test]
2714	····public void HasTypeColumn()
2715	····{
2716	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2717	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2718	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2719	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2720	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2721	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2722	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
2723	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
2724	····}
2725	····[Test]
2726	····public void HasTypeCode()
2727	····{
2728	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2729	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2730	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2731	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2732	····}
2733	}
2734
2735
2736	[TestFixture]
2737	public class MappingTestCmpDirnOwnpconOthpconTblAuto : NDOTest
2738	{
2739	····PersistenceManager pm;
2740	····NDOMapping mapping;
2741	····Class ownClass;
2742	····Class otherClass;
2743	····Class ownDerivedClass;
2744	····Class otherDerivedClass;
2745	····[SetUp]
2746	····public void Setup()
2747	····{
2748	········this.pm = PmFactory.NewPersistenceManager();
2749	········this.mapping = pm.NDOMapping;
2750	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoLeftBase" );
2751	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoRightBase" );
2752	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoLeftDerived" );
2753	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblAutoRightDerived" );
2754	····}
2755	····[Test]
2756	····public void HasMappingTable()
2757	····{
2758	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2759	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2760	····}
2761	····[Test]
2762	····public void HasTypeColumn()
2763	····{
2764	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2765	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2766	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2767	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2768	····}
2769	····[Test]
2770	····public void HasTypeCode()
2771	····{
2772	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2773	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2774	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2775	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2776	····}
2777	}
2778
2779
2780	[TestFixture]
2781	public class MappingTestCmpBin1OwnpconOthpconTblAuto : NDOTest
2782	{
2783	····PersistenceManager pm;
2784	····NDOMapping mapping;
2785	····Class ownClass;
2786	····Class otherClass;
2787	····Class ownDerivedClass;
2788	····Class otherDerivedClass;
2789	····[SetUp]
2790	····public void Setup()
2791	····{
2792	········this.pm = PmFactory.NewPersistenceManager();
2793	········this.mapping = pm.NDOMapping;
2794	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoLeftBase" );
2795	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoRightBase" );
2796	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoLeftDerived" );
2797	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblAutoRightDerived" );
2798	····}
2799	····[Test]
2800	····public void HasMappingTable()
2801	····{
2802	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2803	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2804	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2805	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2806	····}
2807	····[Test]
2808	····public void HasTypeColumn()
2809	····{
2810	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2811	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2812	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2813	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2814	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2815	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2816	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
2817	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
2818	····}
2819	····[Test]
2820	····public void HasTypeCode()
2821	····{
2822	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2823	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2824	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2825	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2826	····}
2827	}
2828
2829
2830	[TestFixture]
2831	public class MappingTestCmpBi1nOwnpconOthpconTblAuto : NDOTest
2832	{
2833	····PersistenceManager pm;
2834	····NDOMapping mapping;
2835	····Class ownClass;
2836	····Class otherClass;
2837	····Class ownDerivedClass;
2838	····Class otherDerivedClass;
2839	····[SetUp]
2840	····public void Setup()
2841	····{
2842	········this.pm = PmFactory.NewPersistenceManager();
2843	········this.mapping = pm.NDOMapping;
2844	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoLeftBase" );
2845	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoRightBase" );
2846	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoLeftDerived" );
2847	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblAutoRightDerived" );
2848	····}
2849	····[Test]
2850	····public void HasMappingTable()
2851	····{
2852	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2853	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2854	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2855	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2856	····}
2857	····[Test]
2858	····public void HasTypeColumn()
2859	····{
2860	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2861	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2862	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2863	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2864	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2865	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2866	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
2867	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
2868	····}
2869	····[Test]
2870	····public void HasTypeCode()
2871	····{
2872	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2873	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2874	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2875	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2876	····}
2877	}
2878
2879
2880	[TestFixture]
2881	public class MappingTestCmpBinnOwnpconOthpconTblAuto : NDOTest
2882	{
2883	····PersistenceManager pm;
2884	····NDOMapping mapping;
2885	····Class ownClass;
2886	····Class otherClass;
2887	····Class ownDerivedClass;
2888	····Class otherDerivedClass;
2889	····[SetUp]
2890	····public void Setup()
2891	····{
2892	········this.pm = PmFactory.NewPersistenceManager();
2893	········this.mapping = pm.NDOMapping;
2894	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoLeftBase" );
2895	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoRightBase" );
2896	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoLeftDerived" );
2897	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblAutoRightDerived" );
2898	····}
2899	····[Test]
2900	····public void HasMappingTable()
2901	····{
2902	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2903	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
2904	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
2905	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
2906	····}
2907	····[Test]
2908	····public void HasTypeColumn()
2909	····{
2910	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
2911	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
2912	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
2913	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
2914	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
2915	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
2916	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
2917	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
2918	····}
2919	····[Test]
2920	····public void HasTypeCode()
2921	····{
2922	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2923	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2924	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
2925	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
2926	····}
2927	}
2928
2929
2930	[TestFixture]
2931	public class MappingTestAgrDir1NoTblGuid : NDOTest
2932	{
2933	····PersistenceManager pm;
2934	····NDOMapping mapping;
2935	····Class ownClass;
2936	····Class otherClass;
2937	····[SetUp]
2938	····public void Setup()
2939	····{
2940	········this.pm = PmFactory.NewPersistenceManager();
2941	········this.mapping = pm.NDOMapping;
2942	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblGuidLeft" );
2943	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1NoTblGuidRight" );
2944	····}
2945	····[Test]
2946	····public void HasMappingTable()
2947	····{
2948	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
2949	····}
2950	····[Test]
2951	····public void HasTypeColumn()
2952	····{
2953	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2954	····}
2955	····[Test]
2956	····public void HasTypeCode()
2957	····{
2958	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2959	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2960	····}
2961	}
2962
2963
2964	[TestFixture]
2965	public class MappingTestAgrDir1TblGuid : NDOTest
2966	{
2967	····PersistenceManager pm;
2968	····NDOMapping mapping;
2969	····Class ownClass;
2970	····Class otherClass;
2971	····[SetUp]
2972	····public void Setup()
2973	····{
2974	········this.pm = PmFactory.NewPersistenceManager();
2975	········this.mapping = pm.NDOMapping;
2976	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblGuidLeft" );
2977	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1TblGuidRight" );
2978	····}
2979	····[Test]
2980	····public void HasMappingTable()
2981	····{
2982	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
2983	····}
2984	····[Test]
2985	····public void HasTypeColumn()
2986	····{
2987	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
2988	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
2989	····}
2990	····[Test]
2991	····public void HasTypeCode()
2992	····{
2993	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
2994	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
2995	····}
2996	}
2997
2998
2999	[TestFixture]
3000	public class MappingTestAgrBi11NoTblGuid : NDOTest
3001	{
3002	····PersistenceManager pm;
3003	····NDOMapping mapping;
3004	····Class ownClass;
3005	····Class otherClass;
3006	····[SetUp]
3007	····public void Setup()
3008	····{
3009	········this.pm = PmFactory.NewPersistenceManager();
3010	········this.mapping = pm.NDOMapping;
3011	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblGuidLeft" );
3012	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11NoTblGuidRight" );
3013	····}
3014	····[Test]
3015	····public void HasMappingTable()
3016	····{
3017	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3018	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
3019	····}
3020	····[Test]
3021	····public void HasTypeColumn()
3022	····{
3023	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3024	····}
3025	····[Test]
3026	····public void HasTypeCode()
3027	····{
3028	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3029	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3030	····}
3031	}
3032
3033
3034	[TestFixture]
3035	public class MappingTestAgrBi11TblGuid : NDOTest
3036	{
3037	····PersistenceManager pm;
3038	····NDOMapping mapping;
3039	····Class ownClass;
3040	····Class otherClass;
3041	····[SetUp]
3042	····public void Setup()
3043	····{
3044	········this.pm = PmFactory.NewPersistenceManager();
3045	········this.mapping = pm.NDOMapping;
3046	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblGuidLeft" );
3047	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11TblGuidRight" );
3048	····}
3049	····[Test]
3050	····public void HasMappingTable()
3051	····{
3052	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3053	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3054	····}
3055	····[Test]
3056	····public void HasTypeColumn()
3057	····{
3058	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3059	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
3060	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3061	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3062	····}
3063	····[Test]
3064	····public void HasTypeCode()
3065	····{
3066	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3067	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3068	····}
3069	}
3070
3071
3072	[TestFixture]
3073	public class MappingTestAgrDirnNoTblGuid : NDOTest
3074	{
3075	····PersistenceManager pm;
3076	····NDOMapping mapping;
3077	····Class ownClass;
3078	····Class otherClass;
3079	····[SetUp]
3080	····public void Setup()
3081	····{
3082	········this.pm = PmFactory.NewPersistenceManager();
3083	········this.mapping = pm.NDOMapping;
3084	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblGuidLeft" );
3085	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnNoTblGuidRight" );
3086	····}
3087	····[Test]
3088	····public void HasMappingTable()
3089	····{
3090	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3091	····}
3092	····[Test]
3093	····public void HasTypeColumn()
3094	····{
3095	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3096	····}
3097	····[Test]
3098	····public void HasTypeCode()
3099	····{
3100	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3101	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3102	····}
3103	}
3104
3105
3106	[TestFixture]
3107	public class MappingTestAgrDirnTblGuid : NDOTest
3108	{
3109	····PersistenceManager pm;
3110	····NDOMapping mapping;
3111	····Class ownClass;
3112	····Class otherClass;
3113	····[SetUp]
3114	····public void Setup()
3115	····{
3116	········this.pm = PmFactory.NewPersistenceManager();
3117	········this.mapping = pm.NDOMapping;
3118	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblGuidLeft" );
3119	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnTblGuidRight" );
3120	····}
3121	····[Test]
3122	····public void HasMappingTable()
3123	····{
3124	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3125	····}
3126	····[Test]
3127	····public void HasTypeColumn()
3128	····{
3129	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3130	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3131	····}
3132	····[Test]
3133	····public void HasTypeCode()
3134	····{
3135	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3136	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3137	····}
3138	}
3139
3140
3141	[TestFixture]
3142	public class MappingTestAgrBin1NoTblGuid : NDOTest
3143	{
3144	····PersistenceManager pm;
3145	····NDOMapping mapping;
3146	····Class ownClass;
3147	····Class otherClass;
3148	····[SetUp]
3149	····public void Setup()
3150	····{
3151	········this.pm = PmFactory.NewPersistenceManager();
3152	········this.mapping = pm.NDOMapping;
3153	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblGuidLeft" );
3154	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1NoTblGuidRight" );
3155	····}
3156	····[Test]
3157	····public void HasMappingTable()
3158	····{
3159	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3160	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
3161	····}
3162	····[Test]
3163	····public void HasTypeColumn()
3164	····{
3165	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3166	····}
3167	····[Test]
3168	····public void HasTypeCode()
3169	····{
3170	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3171	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3172	····}
3173	}
3174
3175
3176	[TestFixture]
3177	public class MappingTestAgrBin1TblGuid : NDOTest
3178	{
3179	····PersistenceManager pm;
3180	····NDOMapping mapping;
3181	····Class ownClass;
3182	····Class otherClass;
3183	····[SetUp]
3184	····public void Setup()
3185	····{
3186	········this.pm = PmFactory.NewPersistenceManager();
3187	········this.mapping = pm.NDOMapping;
3188	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblGuidLeft" );
3189	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1TblGuidRight" );
3190	····}
3191	····[Test]
3192	····public void HasMappingTable()
3193	····{
3194	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3195	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3196	····}
3197	····[Test]
3198	····public void HasTypeColumn()
3199	····{
3200	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3201	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
3202	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3203	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3204	····}
3205	····[Test]
3206	····public void HasTypeCode()
3207	····{
3208	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3209	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3210	····}
3211	}
3212
3213
3214	[TestFixture]
3215	public class MappingTestAgrBi1nNoTblGuid : NDOTest
3216	{
3217	····PersistenceManager pm;
3218	····NDOMapping mapping;
3219	····Class ownClass;
3220	····Class otherClass;
3221	····[SetUp]
3222	····public void Setup()
3223	····{
3224	········this.pm = PmFactory.NewPersistenceManager();
3225	········this.mapping = pm.NDOMapping;
3226	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblGuidLeft" );
3227	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nNoTblGuidRight" );
3228	····}
3229	····[Test]
3230	····public void HasMappingTable()
3231	····{
3232	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3233	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
3234	····}
3235	····[Test]
3236	····public void HasTypeColumn()
3237	····{
3238	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3239	····}
3240	····[Test]
3241	····public void HasTypeCode()
3242	····{
3243	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3244	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3245	····}
3246	}
3247
3248
3249	[TestFixture]
3250	public class MappingTestAgrBi1nTblGuid : NDOTest
3251	{
3252	····PersistenceManager pm;
3253	····NDOMapping mapping;
3254	····Class ownClass;
3255	····Class otherClass;
3256	····[SetUp]
3257	····public void Setup()
3258	····{
3259	········this.pm = PmFactory.NewPersistenceManager();
3260	········this.mapping = pm.NDOMapping;
3261	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblGuidLeft" );
3262	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nTblGuidRight" );
3263	····}
3264	····[Test]
3265	····public void HasMappingTable()
3266	····{
3267	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3268	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3269	····}
3270	····[Test]
3271	····public void HasTypeColumn()
3272	····{
3273	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3274	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
3275	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3276	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3277	····}
3278	····[Test]
3279	····public void HasTypeCode()
3280	····{
3281	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3282	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3283	····}
3284	}
3285
3286
3287	[TestFixture]
3288	public class MappingTestAgrBinnTblGuid : NDOTest
3289	{
3290	····PersistenceManager pm;
3291	····NDOMapping mapping;
3292	····Class ownClass;
3293	····Class otherClass;
3294	····[SetUp]
3295	····public void Setup()
3296	····{
3297	········this.pm = PmFactory.NewPersistenceManager();
3298	········this.mapping = pm.NDOMapping;
3299	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblGuidLeft" );
3300	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnTblGuidRight" );
3301	····}
3302	····[Test]
3303	····public void HasMappingTable()
3304	····{
3305	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3306	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3307	····}
3308	····[Test]
3309	····public void HasTypeColumn()
3310	····{
3311	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3312	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
3313	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3314	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3315	····}
3316	····[Test]
3317	····public void HasTypeCode()
3318	····{
3319	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3320	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3321	····}
3322	}
3323
3324
3325	[TestFixture]
3326	public class MappingTestCmpDir1NoTblGuid : NDOTest
3327	{
3328	····PersistenceManager pm;
3329	····NDOMapping mapping;
3330	····Class ownClass;
3331	····Class otherClass;
3332	····[SetUp]
3333	····public void Setup()
3334	····{
3335	········this.pm = PmFactory.NewPersistenceManager();
3336	········this.mapping = pm.NDOMapping;
3337	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblGuidLeft" );
3338	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1NoTblGuidRight" );
3339	····}
3340	····[Test]
3341	····public void HasMappingTable()
3342	····{
3343	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3344	····}
3345	····[Test]
3346	····public void HasTypeColumn()
3347	····{
3348	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3349	····}
3350	····[Test]
3351	····public void HasTypeCode()
3352	····{
3353	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3354	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3355	····}
3356	}
3357
3358
3359	[TestFixture]
3360	public class MappingTestCmpDir1TblGuid : NDOTest
3361	{
3362	····PersistenceManager pm;
3363	····NDOMapping mapping;
3364	····Class ownClass;
3365	····Class otherClass;
3366	····[SetUp]
3367	····public void Setup()
3368	····{
3369	········this.pm = PmFactory.NewPersistenceManager();
3370	········this.mapping = pm.NDOMapping;
3371	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblGuidLeft" );
3372	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1TblGuidRight" );
3373	····}
3374	····[Test]
3375	····public void HasMappingTable()
3376	····{
3377	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3378	····}
3379	····[Test]
3380	····public void HasTypeColumn()
3381	····{
3382	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3383	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3384	····}
3385	····[Test]
3386	····public void HasTypeCode()
3387	····{
3388	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3389	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3390	····}
3391	}
3392
3393
3394	[TestFixture]
3395	public class MappingTestCmpBi11NoTblGuid : NDOTest
3396	{
3397	····PersistenceManager pm;
3398	····NDOMapping mapping;
3399	····Class ownClass;
3400	····Class otherClass;
3401	····[SetUp]
3402	····public void Setup()
3403	····{
3404	········this.pm = PmFactory.NewPersistenceManager();
3405	········this.mapping = pm.NDOMapping;
3406	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblGuidLeft" );
3407	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11NoTblGuidRight" );
3408	····}
3409	····[Test]
3410	····public void HasMappingTable()
3411	····{
3412	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3413	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
3414	····}
3415	····[Test]
3416	····public void HasTypeColumn()
3417	····{
3418	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3419	····}
3420	····[Test]
3421	····public void HasTypeCode()
3422	····{
3423	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3424	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3425	····}
3426	}
3427
3428
3429	[TestFixture]
3430	public class MappingTestCmpBi11TblGuid : NDOTest
3431	{
3432	····PersistenceManager pm;
3433	····NDOMapping mapping;
3434	····Class ownClass;
3435	····Class otherClass;
3436	····[SetUp]
3437	····public void Setup()
3438	····{
3439	········this.pm = PmFactory.NewPersistenceManager();
3440	········this.mapping = pm.NDOMapping;
3441	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblGuidLeft" );
3442	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11TblGuidRight" );
3443	····}
3444	····[Test]
3445	····public void HasMappingTable()
3446	····{
3447	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3448	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3449	····}
3450	····[Test]
3451	····public void HasTypeColumn()
3452	····{
3453	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3454	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
3455	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3456	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3457	····}
3458	····[Test]
3459	····public void HasTypeCode()
3460	····{
3461	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3462	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3463	····}
3464	}
3465
3466
3467	[TestFixture]
3468	public class MappingTestCmpDirnNoTblGuid : NDOTest
3469	{
3470	····PersistenceManager pm;
3471	····NDOMapping mapping;
3472	····Class ownClass;
3473	····Class otherClass;
3474	····[SetUp]
3475	····public void Setup()
3476	····{
3477	········this.pm = PmFactory.NewPersistenceManager();
3478	········this.mapping = pm.NDOMapping;
3479	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblGuidLeft" );
3480	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnNoTblGuidRight" );
3481	····}
3482	····[Test]
3483	····public void HasMappingTable()
3484	····{
3485	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3486	····}
3487	····[Test]
3488	····public void HasTypeColumn()
3489	····{
3490	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3491	····}
3492	····[Test]
3493	····public void HasTypeCode()
3494	····{
3495	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3496	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3497	····}
3498	}
3499
3500
3501	[TestFixture]
3502	public class MappingTestCmpDirnTblGuid : NDOTest
3503	{
3504	····PersistenceManager pm;
3505	····NDOMapping mapping;
3506	····Class ownClass;
3507	····Class otherClass;
3508	····[SetUp]
3509	····public void Setup()
3510	····{
3511	········this.pm = PmFactory.NewPersistenceManager();
3512	········this.mapping = pm.NDOMapping;
3513	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblGuidLeft" );
3514	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnTblGuidRight" );
3515	····}
3516	····[Test]
3517	····public void HasMappingTable()
3518	····{
3519	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3520	····}
3521	····[Test]
3522	····public void HasTypeColumn()
3523	····{
3524	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3525	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3526	····}
3527	····[Test]
3528	····public void HasTypeCode()
3529	····{
3530	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3531	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3532	····}
3533	}
3534
3535
3536	[TestFixture]
3537	public class MappingTestCmpBin1NoTblGuid : NDOTest
3538	{
3539	····PersistenceManager pm;
3540	····NDOMapping mapping;
3541	····Class ownClass;
3542	····Class otherClass;
3543	····[SetUp]
3544	····public void Setup()
3545	····{
3546	········this.pm = PmFactory.NewPersistenceManager();
3547	········this.mapping = pm.NDOMapping;
3548	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblGuidLeft" );
3549	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1NoTblGuidRight" );
3550	····}
3551	····[Test]
3552	····public void HasMappingTable()
3553	····{
3554	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3555	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
3556	····}
3557	····[Test]
3558	····public void HasTypeColumn()
3559	····{
3560	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3561	····}
3562	····[Test]
3563	····public void HasTypeCode()
3564	····{
3565	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3566	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3567	····}
3568	}
3569
3570
3571	[TestFixture]
3572	public class MappingTestCmpBin1TblGuid : NDOTest
3573	{
3574	····PersistenceManager pm;
3575	····NDOMapping mapping;
3576	····Class ownClass;
3577	····Class otherClass;
3578	····[SetUp]
3579	····public void Setup()
3580	····{
3581	········this.pm = PmFactory.NewPersistenceManager();
3582	········this.mapping = pm.NDOMapping;
3583	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblGuidLeft" );
3584	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1TblGuidRight" );
3585	····}
3586	····[Test]
3587	····public void HasMappingTable()
3588	····{
3589	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3590	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3591	····}
3592	····[Test]
3593	····public void HasTypeColumn()
3594	····{
3595	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3596	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
3597	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3598	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3599	····}
3600	····[Test]
3601	····public void HasTypeCode()
3602	····{
3603	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3604	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3605	····}
3606	}
3607
3608
3609	[TestFixture]
3610	public class MappingTestCmpBi1nNoTblGuid : NDOTest
3611	{
3612	····PersistenceManager pm;
3613	····NDOMapping mapping;
3614	····Class ownClass;
3615	····Class otherClass;
3616	····[SetUp]
3617	····public void Setup()
3618	····{
3619	········this.pm = PmFactory.NewPersistenceManager();
3620	········this.mapping = pm.NDOMapping;
3621	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblGuidLeft" );
3622	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nNoTblGuidRight" );
3623	····}
3624	····[Test]
3625	····public void HasMappingTable()
3626	····{
3627	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3628	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
3629	····}
3630	····[Test]
3631	····public void HasTypeColumn()
3632	····{
3633	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3634	····}
3635	····[Test]
3636	····public void HasTypeCode()
3637	····{
3638	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3639	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3640	····}
3641	}
3642
3643
3644	[TestFixture]
3645	public class MappingTestCmpBi1nTblGuid : NDOTest
3646	{
3647	····PersistenceManager pm;
3648	····NDOMapping mapping;
3649	····Class ownClass;
3650	····Class otherClass;
3651	····[SetUp]
3652	····public void Setup()
3653	····{
3654	········this.pm = PmFactory.NewPersistenceManager();
3655	········this.mapping = pm.NDOMapping;
3656	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblGuidLeft" );
3657	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nTblGuidRight" );
3658	····}
3659	····[Test]
3660	····public void HasMappingTable()
3661	····{
3662	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3663	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3664	····}
3665	····[Test]
3666	····public void HasTypeColumn()
3667	····{
3668	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3669	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
3670	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3671	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3672	····}
3673	····[Test]
3674	····public void HasTypeCode()
3675	····{
3676	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3677	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3678	····}
3679	}
3680
3681
3682	[TestFixture]
3683	public class MappingTestCmpBinnTblGuid : NDOTest
3684	{
3685	····PersistenceManager pm;
3686	····NDOMapping mapping;
3687	····Class ownClass;
3688	····Class otherClass;
3689	····[SetUp]
3690	····public void Setup()
3691	····{
3692	········this.pm = PmFactory.NewPersistenceManager();
3693	········this.mapping = pm.NDOMapping;
3694	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblGuidLeft" );
3695	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnTblGuidRight" );
3696	····}
3697	····[Test]
3698	····public void HasMappingTable()
3699	····{
3700	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3701	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3702	····}
3703	····[Test]
3704	····public void HasTypeColumn()
3705	····{
3706	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3707	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
3708	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3709	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3710	····}
3711	····[Test]
3712	····public void HasTypeCode()
3713	····{
3714	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3715	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3716	····}
3717	}
3718
3719
3720	[TestFixture]
3721	public class MappingTestAgrDir1OwnpconNoTblGuid : NDOTest
3722	{
3723	····PersistenceManager pm;
3724	····NDOMapping mapping;
3725	····Class ownClass;
3726	····Class otherClass;
3727	····Class ownDerivedClass;
3728	····[SetUp]
3729	····public void Setup()
3730	····{
3731	········this.pm = PmFactory.NewPersistenceManager();
3732	········this.mapping = pm.NDOMapping;
3733	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidLeftBase" );
3734	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidRight" );
3735	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconNoTblGuidLeftDerived" );
3736	····}
3737	····[Test]
3738	····public void HasMappingTable()
3739	····{
3740	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3741	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
3742	····}
3743	····[Test]
3744	····public void HasTypeColumn()
3745	····{
3746	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3747	····}
3748	····[Test]
3749	····public void HasTypeCode()
3750	····{
3751	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3752	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3753	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3754	····}
3755	}
3756
3757
3758	[TestFixture]
3759	public class MappingTestAgrDir1OwnpconTblGuid : NDOTest
3760	{
3761	····PersistenceManager pm;
3762	····NDOMapping mapping;
3763	····Class ownClass;
3764	····Class otherClass;
3765	····Class ownDerivedClass;
3766	····[SetUp]
3767	····public void Setup()
3768	····{
3769	········this.pm = PmFactory.NewPersistenceManager();
3770	········this.mapping = pm.NDOMapping;
3771	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidLeftBase" );
3772	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidRight" );
3773	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconTblGuidLeftDerived" );
3774	····}
3775	····[Test]
3776	····public void HasMappingTable()
3777	····{
3778	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3779	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
3780	····}
3781	····[Test]
3782	····public void HasTypeColumn()
3783	····{
3784	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
3785	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
3786	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3787	····}
3788	····[Test]
3789	····public void HasTypeCode()
3790	····{
3791	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3792	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3793	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3794	····}
3795	}
3796
3797
3798	[TestFixture]
3799	public class MappingTestAgrBi11OwnpconNoTblGuid : NDOTest
3800	{
3801	····PersistenceManager pm;
3802	····NDOMapping mapping;
3803	····Class ownClass;
3804	····Class otherClass;
3805	····Class ownDerivedClass;
3806	····[SetUp]
3807	····public void Setup()
3808	····{
3809	········this.pm = PmFactory.NewPersistenceManager();
3810	········this.mapping = pm.NDOMapping;
3811	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidLeftBase" );
3812	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidRight" );
3813	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconNoTblGuidLeftDerived" );
3814	····}
3815	····[Test]
3816	····public void HasMappingTable()
3817	····{
3818	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3819	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
3820	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
3821	····}
3822	····[Test]
3823	····public void HasTypeColumn()
3824	····{
3825	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3826	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
3827	····}
3828	····[Test]
3829	····public void HasTypeCode()
3830	····{
3831	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3832	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3833	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3834	····}
3835	}
3836
3837
3838	[TestFixture]
3839	public class MappingTestAgrBi11OwnpconTblGuid : NDOTest
3840	{
3841	····PersistenceManager pm;
3842	····NDOMapping mapping;
3843	····Class ownClass;
3844	····Class otherClass;
3845	····Class ownDerivedClass;
3846	····[SetUp]
3847	····public void Setup()
3848	····{
3849	········this.pm = PmFactory.NewPersistenceManager();
3850	········this.mapping = pm.NDOMapping;
3851	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidLeftBase" );
3852	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidRight" );
3853	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconTblGuidLeftDerived" );
3854	····}
3855	····[Test]
3856	····public void HasMappingTable()
3857	····{
3858	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3859	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
3860	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
3861	····}
3862	····[Test]
3863	····public void HasTypeColumn()
3864	····{
3865	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
3866	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
3867	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
3868	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3869	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
3870	····}
3871	····[Test]
3872	····public void HasTypeCode()
3873	····{
3874	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3875	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3876	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3877	····}
3878	}
3879
3880
3881	[TestFixture]
3882	public class MappingTestAgrDirnOwnpconNoTblGuid : NDOTest
3883	{
3884	····PersistenceManager pm;
3885	····NDOMapping mapping;
3886	····Class ownClass;
3887	····Class otherClass;
3888	····Class ownDerivedClass;
3889	····[SetUp]
3890	····public void Setup()
3891	····{
3892	········this.pm = PmFactory.NewPersistenceManager();
3893	········this.mapping = pm.NDOMapping;
3894	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidLeftBase" );
3895	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidRight" );
3896	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconNoTblGuidLeftDerived" );
3897	····}
3898	····[Test]
3899	····public void HasMappingTable()
3900	····{
3901	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3902	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
3903	····}
3904	····[Test]
3905	····public void HasTypeColumn()
3906	····{
3907	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3908	····}
3909	····[Test]
3910	····public void HasTypeCode()
3911	····{
3912	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3913	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3914	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3915	····}
3916	}
3917
3918
3919	[TestFixture]
3920	public class MappingTestAgrDirnOwnpconTblGuid : NDOTest
3921	{
3922	····PersistenceManager pm;
3923	····NDOMapping mapping;
3924	····Class ownClass;
3925	····Class otherClass;
3926	····Class ownDerivedClass;
3927	····[SetUp]
3928	····public void Setup()
3929	····{
3930	········this.pm = PmFactory.NewPersistenceManager();
3931	········this.mapping = pm.NDOMapping;
3932	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidLeftBase" );
3933	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidRight" );
3934	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconTblGuidLeftDerived" );
3935	····}
3936	····[Test]
3937	····public void HasMappingTable()
3938	····{
3939	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
3940	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
3941	····}
3942	····[Test]
3943	····public void HasTypeColumn()
3944	····{
3945	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
3946	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
3947	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
3948	····}
3949	····[Test]
3950	····public void HasTypeCode()
3951	····{
3952	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3953	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3954	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3955	····}
3956	}
3957
3958
3959	[TestFixture]
3960	public class MappingTestAgrBin1OwnpconNoTblGuid : NDOTest
3961	{
3962	····PersistenceManager pm;
3963	····NDOMapping mapping;
3964	····Class ownClass;
3965	····Class otherClass;
3966	····Class ownDerivedClass;
3967	····[SetUp]
3968	····public void Setup()
3969	····{
3970	········this.pm = PmFactory.NewPersistenceManager();
3971	········this.mapping = pm.NDOMapping;
3972	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidLeftBase" );
3973	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidRight" );
3974	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconNoTblGuidLeftDerived" );
3975	····}
3976	····[Test]
3977	····public void HasMappingTable()
3978	····{
3979	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
3980	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
3981	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
3982	····}
3983	····[Test]
3984	····public void HasTypeColumn()
3985	····{
3986	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
3987	····}
3988	····[Test]
3989	····public void HasTypeCode()
3990	····{
3991	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
3992	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
3993	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
3994	····}
3995	}
3996
3997
3998	[TestFixture]
3999	public class MappingTestAgrBin1OwnpconTblGuid : NDOTest
4000	{
4001	····PersistenceManager pm;
4002	····NDOMapping mapping;
4003	····Class ownClass;
4004	····Class otherClass;
4005	····Class ownDerivedClass;
4006	····[SetUp]
4007	····public void Setup()
4008	····{
4009	········this.pm = PmFactory.NewPersistenceManager();
4010	········this.mapping = pm.NDOMapping;
4011	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidLeftBase" );
4012	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidRight" );
4013	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconTblGuidLeftDerived" );
4014	····}
4015	····[Test]
4016	····public void HasMappingTable()
4017	····{
4018	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4019	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4020	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4021	····}
4022	····[Test]
4023	····public void HasTypeColumn()
4024	····{
4025	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4026	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4027	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
4028	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4029	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
4030	····}
4031	····[Test]
4032	····public void HasTypeCode()
4033	····{
4034	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4035	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4036	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4037	····}
4038	}
4039
4040
4041	[TestFixture]
4042	public class MappingTestAgrBi1nOwnpconTblGuid : NDOTest
4043	{
4044	····PersistenceManager pm;
4045	····NDOMapping mapping;
4046	····Class ownClass;
4047	····Class otherClass;
4048	····Class ownDerivedClass;
4049	····[SetUp]
4050	····public void Setup()
4051	····{
4052	········this.pm = PmFactory.NewPersistenceManager();
4053	········this.mapping = pm.NDOMapping;
4054	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidLeftBase" );
4055	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidRight" );
4056	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconTblGuidLeftDerived" );
4057	····}
4058	····[Test]
4059	····public void HasMappingTable()
4060	····{
4061	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4062	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4063	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4064	····}
4065	····[Test]
4066	····public void HasTypeColumn()
4067	····{
4068	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4069	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4070	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
4071	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4072	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
4073	····}
4074	····[Test]
4075	····public void HasTypeCode()
4076	····{
4077	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4078	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4079	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4080	····}
4081	}
4082
4083
4084	[TestFixture]
4085	public class MappingTestAgrBinnOwnpconTblGuid : NDOTest
4086	{
4087	····PersistenceManager pm;
4088	····NDOMapping mapping;
4089	····Class ownClass;
4090	····Class otherClass;
4091	····Class ownDerivedClass;
4092	····[SetUp]
4093	····public void Setup()
4094	····{
4095	········this.pm = PmFactory.NewPersistenceManager();
4096	········this.mapping = pm.NDOMapping;
4097	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidLeftBase" );
4098	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidRight" );
4099	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconTblGuidLeftDerived" );
4100	····}
4101	····[Test]
4102	····public void HasMappingTable()
4103	····{
4104	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4105	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4106	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4107	····}
4108	····[Test]
4109	····public void HasTypeColumn()
4110	····{
4111	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4112	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4113	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
4114	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4115	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
4116	····}
4117	····[Test]
4118	····public void HasTypeCode()
4119	····{
4120	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4121	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4122	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4123	····}
4124	}
4125
4126
4127	[TestFixture]
4128	public class MappingTestCmpDir1OwnpconNoTblGuid : NDOTest
4129	{
4130	····PersistenceManager pm;
4131	····NDOMapping mapping;
4132	····Class ownClass;
4133	····Class otherClass;
4134	····Class ownDerivedClass;
4135	····[SetUp]
4136	····public void Setup()
4137	····{
4138	········this.pm = PmFactory.NewPersistenceManager();
4139	········this.mapping = pm.NDOMapping;
4140	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidLeftBase" );
4141	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidRight" );
4142	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconNoTblGuidLeftDerived" );
4143	····}
4144	····[Test]
4145	····public void HasMappingTable()
4146	····{
4147	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4148	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
4149	····}
4150	····[Test]
4151	····public void HasTypeColumn()
4152	····{
4153	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4154	····}
4155	····[Test]
4156	····public void HasTypeCode()
4157	····{
4158	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4159	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4160	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4161	····}
4162	}
4163
4164
4165	[TestFixture]
4166	public class MappingTestCmpDir1OwnpconTblGuid : NDOTest
4167	{
4168	····PersistenceManager pm;
4169	····NDOMapping mapping;
4170	····Class ownClass;
4171	····Class otherClass;
4172	····Class ownDerivedClass;
4173	····[SetUp]
4174	····public void Setup()
4175	····{
4176	········this.pm = PmFactory.NewPersistenceManager();
4177	········this.mapping = pm.NDOMapping;
4178	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidLeftBase" );
4179	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidRight" );
4180	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconTblGuidLeftDerived" );
4181	····}
4182	····[Test]
4183	····public void HasMappingTable()
4184	····{
4185	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4186	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4187	····}
4188	····[Test]
4189	····public void HasTypeColumn()
4190	····{
4191	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4192	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4193	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4194	····}
4195	····[Test]
4196	····public void HasTypeCode()
4197	····{
4198	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4199	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4200	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4201	····}
4202	}
4203
4204
4205	[TestFixture]
4206	public class MappingTestCmpBi11OwnpconNoTblGuid : NDOTest
4207	{
4208	····PersistenceManager pm;
4209	····NDOMapping mapping;
4210	····Class ownClass;
4211	····Class otherClass;
4212	····Class ownDerivedClass;
4213	····[SetUp]
4214	····public void Setup()
4215	····{
4216	········this.pm = PmFactory.NewPersistenceManager();
4217	········this.mapping = pm.NDOMapping;
4218	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidLeftBase" );
4219	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidRight" );
4220	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconNoTblGuidLeftDerived" );
4221	····}
4222	····[Test]
4223	····public void HasMappingTable()
4224	····{
4225	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4226	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
4227	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
4228	····}
4229	····[Test]
4230	····public void HasTypeColumn()
4231	····{
4232	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4233	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
4234	····}
4235	····[Test]
4236	····public void HasTypeCode()
4237	····{
4238	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4239	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4240	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4241	····}
4242	}
4243
4244
4245	[TestFixture]
4246	public class MappingTestCmpBi11OwnpconTblGuid : NDOTest
4247	{
4248	····PersistenceManager pm;
4249	····NDOMapping mapping;
4250	····Class ownClass;
4251	····Class otherClass;
4252	····Class ownDerivedClass;
4253	····[SetUp]
4254	····public void Setup()
4255	····{
4256	········this.pm = PmFactory.NewPersistenceManager();
4257	········this.mapping = pm.NDOMapping;
4258	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidLeftBase" );
4259	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidRight" );
4260	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconTblGuidLeftDerived" );
4261	····}
4262	····[Test]
4263	····public void HasMappingTable()
4264	····{
4265	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4266	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4267	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4268	····}
4269	····[Test]
4270	····public void HasTypeColumn()
4271	····{
4272	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4273	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4274	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
4275	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4276	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
4277	····}
4278	····[Test]
4279	····public void HasTypeCode()
4280	····{
4281	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4282	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4283	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4284	····}
4285	}
4286
4287
4288	[TestFixture]
4289	public class MappingTestCmpDirnOwnpconNoTblGuid : NDOTest
4290	{
4291	····PersistenceManager pm;
4292	····NDOMapping mapping;
4293	····Class ownClass;
4294	····Class otherClass;
4295	····Class ownDerivedClass;
4296	····[SetUp]
4297	····public void Setup()
4298	····{
4299	········this.pm = PmFactory.NewPersistenceManager();
4300	········this.mapping = pm.NDOMapping;
4301	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidLeftBase" );
4302	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidRight" );
4303	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconNoTblGuidLeftDerived" );
4304	····}
4305	····[Test]
4306	····public void HasMappingTable()
4307	····{
4308	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4309	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
4310	····}
4311	····[Test]
4312	····public void HasTypeColumn()
4313	····{
4314	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4315	····}
4316	····[Test]
4317	····public void HasTypeCode()
4318	····{
4319	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4320	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4321	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4322	····}
4323	}
4324
4325
4326	[TestFixture]
4327	public class MappingTestCmpDirnOwnpconTblGuid : NDOTest
4328	{
4329	····PersistenceManager pm;
4330	····NDOMapping mapping;
4331	····Class ownClass;
4332	····Class otherClass;
4333	····Class ownDerivedClass;
4334	····[SetUp]
4335	····public void Setup()
4336	····{
4337	········this.pm = PmFactory.NewPersistenceManager();
4338	········this.mapping = pm.NDOMapping;
4339	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidLeftBase" );
4340	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidRight" );
4341	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconTblGuidLeftDerived" );
4342	····}
4343	····[Test]
4344	····public void HasMappingTable()
4345	····{
4346	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4347	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4348	····}
4349	····[Test]
4350	····public void HasTypeColumn()
4351	····{
4352	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4353	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4354	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4355	····}
4356	····[Test]
4357	····public void HasTypeCode()
4358	····{
4359	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4360	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4361	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4362	····}
4363	}
4364
4365
4366	[TestFixture]
4367	public class MappingTestCmpBin1OwnpconNoTblGuid : NDOTest
4368	{
4369	····PersistenceManager pm;
4370	····NDOMapping mapping;
4371	····Class ownClass;
4372	····Class otherClass;
4373	····Class ownDerivedClass;
4374	····[SetUp]
4375	····public void Setup()
4376	····{
4377	········this.pm = PmFactory.NewPersistenceManager();
4378	········this.mapping = pm.NDOMapping;
4379	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidLeftBase" );
4380	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidRight" );
4381	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconNoTblGuidLeftDerived" );
4382	····}
4383	····[Test]
4384	····public void HasMappingTable()
4385	····{
4386	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4387	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
4388	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
4389	····}
4390	····[Test]
4391	····public void HasTypeColumn()
4392	····{
4393	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4394	····}
4395	····[Test]
4396	····public void HasTypeCode()
4397	····{
4398	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4399	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4400	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4401	····}
4402	}
4403
4404
4405	[TestFixture]
4406	public class MappingTestCmpBin1OwnpconTblGuid : NDOTest
4407	{
4408	····PersistenceManager pm;
4409	····NDOMapping mapping;
4410	····Class ownClass;
4411	····Class otherClass;
4412	····Class ownDerivedClass;
4413	····[SetUp]
4414	····public void Setup()
4415	····{
4416	········this.pm = PmFactory.NewPersistenceManager();
4417	········this.mapping = pm.NDOMapping;
4418	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidLeftBase" );
4419	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidRight" );
4420	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconTblGuidLeftDerived" );
4421	····}
4422	····[Test]
4423	····public void HasMappingTable()
4424	····{
4425	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4426	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4427	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4428	····}
4429	····[Test]
4430	····public void HasTypeColumn()
4431	····{
4432	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4433	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4434	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
4435	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4436	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
4437	····}
4438	····[Test]
4439	····public void HasTypeCode()
4440	····{
4441	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4442	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4443	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4444	····}
4445	}
4446
4447
4448	[TestFixture]
4449	public class MappingTestCmpBi1nOwnpconTblGuid : NDOTest
4450	{
4451	····PersistenceManager pm;
4452	····NDOMapping mapping;
4453	····Class ownClass;
4454	····Class otherClass;
4455	····Class ownDerivedClass;
4456	····[SetUp]
4457	····public void Setup()
4458	····{
4459	········this.pm = PmFactory.NewPersistenceManager();
4460	········this.mapping = pm.NDOMapping;
4461	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidLeftBase" );
4462	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidRight" );
4463	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconTblGuidLeftDerived" );
4464	····}
4465	····[Test]
4466	····public void HasMappingTable()
4467	····{
4468	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4469	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4470	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4471	····}
4472	····[Test]
4473	····public void HasTypeColumn()
4474	····{
4475	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4476	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4477	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
4478	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4479	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
4480	····}
4481	····[Test]
4482	····public void HasTypeCode()
4483	····{
4484	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4485	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4486	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4487	····}
4488	}
4489
4490
4491	[TestFixture]
4492	public class MappingTestCmpBinnOwnpconTblGuid : NDOTest
4493	{
4494	····PersistenceManager pm;
4495	····NDOMapping mapping;
4496	····Class ownClass;
4497	····Class otherClass;
4498	····Class ownDerivedClass;
4499	····[SetUp]
4500	····public void Setup()
4501	····{
4502	········this.pm = PmFactory.NewPersistenceManager();
4503	········this.mapping = pm.NDOMapping;
4504	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidLeftBase" );
4505	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidRight" );
4506	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconTblGuidLeftDerived" );
4507	····}
4508	····[Test]
4509	····public void HasMappingTable()
4510	····{
4511	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4512	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
4513	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4514	····}
4515	····[Test]
4516	····public void HasTypeColumn()
4517	····{
4518	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
4519	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
4520	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
4521	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
4522	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
4523	····}
4524	····[Test]
4525	····public void HasTypeCode()
4526	····{
4527	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4528	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4529	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
4530	····}
4531	}
4532
4533
4534	[TestFixture]
4535	public class MappingTestAgrDir1OthpconNoTblGuid : NDOTest
4536	{
4537	····PersistenceManager pm;
4538	····NDOMapping mapping;
4539	····Class ownClass;
4540	····Class otherClass;
4541	····Class otherDerivedClass;
4542	····[SetUp]
4543	····public void Setup()
4544	····{
4545	········this.pm = PmFactory.NewPersistenceManager();
4546	········this.mapping = pm.NDOMapping;
4547	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidLeft" );
4548	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidRightBase" );
4549	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconNoTblGuidRightDerived" );
4550	····}
4551	····[Test]
4552	····public void HasMappingTable()
4553	····{
4554	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4555	····}
4556	····[Test]
4557	····public void HasTypeColumn()
4558	····{
4559	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
4560	····}
4561	····[Test]
4562	····public void HasTypeCode()
4563	····{
4564	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4565	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4566	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4567	····}
4568	}
4569
4570
4571	[TestFixture]
4572	public class MappingTestAgrDir1OthpconTblGuid : NDOTest
4573	{
4574	····PersistenceManager pm;
4575	····NDOMapping mapping;
4576	····Class ownClass;
4577	····Class otherClass;
4578	····Class otherDerivedClass;
4579	····[SetUp]
4580	····public void Setup()
4581	····{
4582	········this.pm = PmFactory.NewPersistenceManager();
4583	········this.mapping = pm.NDOMapping;
4584	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidLeft" );
4585	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidRightBase" );
4586	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpconTblGuidRightDerived" );
4587	····}
4588	····[Test]
4589	····public void HasMappingTable()
4590	····{
4591	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4592	····}
4593	····[Test]
4594	····public void HasTypeColumn()
4595	····{
4596	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
4597	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4598	····}
4599	····[Test]
4600	····public void HasTypeCode()
4601	····{
4602	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4603	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4604	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4605	····}
4606	}
4607
4608
4609	[TestFixture]
4610	public class MappingTestAgrBi11OthpconNoTblGuid : NDOTest
4611	{
4612	····PersistenceManager pm;
4613	····NDOMapping mapping;
4614	····Class ownClass;
4615	····Class otherClass;
4616	····Class otherDerivedClass;
4617	····[SetUp]
4618	····public void Setup()
4619	····{
4620	········this.pm = PmFactory.NewPersistenceManager();
4621	········this.mapping = pm.NDOMapping;
4622	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidLeft" );
4623	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidRightBase" );
4624	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconNoTblGuidRightDerived" );
4625	····}
4626	····[Test]
4627	····public void HasMappingTable()
4628	····{
4629	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4630	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
4631	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
4632	····}
4633	····[Test]
4634	····public void HasTypeColumn()
4635	····{
4636	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
4637	····}
4638	····[Test]
4639	····public void HasTypeCode()
4640	····{
4641	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4642	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4643	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4644	····}
4645	}
4646
4647
4648	[TestFixture]
4649	public class MappingTestAgrBi11OthpconTblGuid : NDOTest
4650	{
4651	····PersistenceManager pm;
4652	····NDOMapping mapping;
4653	····Class ownClass;
4654	····Class otherClass;
4655	····Class otherDerivedClass;
4656	····[SetUp]
4657	····public void Setup()
4658	····{
4659	········this.pm = PmFactory.NewPersistenceManager();
4660	········this.mapping = pm.NDOMapping;
4661	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidLeft" );
4662	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidRightBase" );
4663	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpconTblGuidRightDerived" );
4664	····}
4665	····[Test]
4666	····public void HasMappingTable()
4667	····{
4668	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4669	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4670	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
4671	····}
4672	····[Test]
4673	····public void HasTypeColumn()
4674	····{
4675	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
4676	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
4677	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
4678	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4679	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
4680	····}
4681	····[Test]
4682	····public void HasTypeCode()
4683	····{
4684	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4685	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4686	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4687	····}
4688	}
4689
4690
4691	[TestFixture]
4692	public class MappingTestAgrDirnOthpconTblGuid : NDOTest
4693	{
4694	····PersistenceManager pm;
4695	····NDOMapping mapping;
4696	····Class ownClass;
4697	····Class otherClass;
4698	····Class otherDerivedClass;
4699	····[SetUp]
4700	····public void Setup()
4701	····{
4702	········this.pm = PmFactory.NewPersistenceManager();
4703	········this.mapping = pm.NDOMapping;
4704	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidLeft" );
4705	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidRightBase" );
4706	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpconTblGuidRightDerived" );
4707	····}
4708	····[Test]
4709	····public void HasMappingTable()
4710	····{
4711	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4712	····}
4713	····[Test]
4714	····public void HasTypeColumn()
4715	····{
4716	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
4717	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4718	····}
4719	····[Test]
4720	····public void HasTypeCode()
4721	····{
4722	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4723	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4724	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4725	····}
4726	}
4727
4728
4729	[TestFixture]
4730	public class MappingTestAgrBin1OthpconTblGuid : NDOTest
4731	{
4732	····PersistenceManager pm;
4733	····NDOMapping mapping;
4734	····Class ownClass;
4735	····Class otherClass;
4736	····Class otherDerivedClass;
4737	····[SetUp]
4738	····public void Setup()
4739	····{
4740	········this.pm = PmFactory.NewPersistenceManager();
4741	········this.mapping = pm.NDOMapping;
4742	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidLeft" );
4743	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidRightBase" );
4744	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpconTblGuidRightDerived" );
4745	····}
4746	····[Test]
4747	····public void HasMappingTable()
4748	····{
4749	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4750	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4751	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
4752	····}
4753	····[Test]
4754	····public void HasTypeColumn()
4755	····{
4756	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
4757	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
4758	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
4759	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4760	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
4761	····}
4762	····[Test]
4763	····public void HasTypeCode()
4764	····{
4765	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4766	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4767	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4768	····}
4769	}
4770
4771
4772	[TestFixture]
4773	public class MappingTestAgrBi1nOthpconNoTblGuid : NDOTest
4774	{
4775	····PersistenceManager pm;
4776	····NDOMapping mapping;
4777	····Class ownClass;
4778	····Class otherClass;
4779	····Class otherDerivedClass;
4780	····[SetUp]
4781	····public void Setup()
4782	····{
4783	········this.pm = PmFactory.NewPersistenceManager();
4784	········this.mapping = pm.NDOMapping;
4785	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidLeft" );
4786	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidRightBase" );
4787	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconNoTblGuidRightDerived" );
4788	····}
4789	····[Test]
4790	····public void HasMappingTable()
4791	····{
4792	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4793	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
4794	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
4795	····}
4796	····[Test]
4797	····public void HasTypeColumn()
4798	····{
4799	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
4800	····}
4801	····[Test]
4802	····public void HasTypeCode()
4803	····{
4804	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4805	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4806	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4807	····}
4808	}
4809
4810
4811	[TestFixture]
4812	public class MappingTestAgrBi1nOthpconTblGuid : NDOTest
4813	{
4814	····PersistenceManager pm;
4815	····NDOMapping mapping;
4816	····Class ownClass;
4817	····Class otherClass;
4818	····Class otherDerivedClass;
4819	····[SetUp]
4820	····public void Setup()
4821	····{
4822	········this.pm = PmFactory.NewPersistenceManager();
4823	········this.mapping = pm.NDOMapping;
4824	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidLeft" );
4825	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidRightBase" );
4826	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpconTblGuidRightDerived" );
4827	····}
4828	····[Test]
4829	····public void HasMappingTable()
4830	····{
4831	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4832	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4833	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
4834	····}
4835	····[Test]
4836	····public void HasTypeColumn()
4837	····{
4838	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
4839	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
4840	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
4841	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4842	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
4843	····}
4844	····[Test]
4845	····public void HasTypeCode()
4846	····{
4847	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4848	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4849	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4850	····}
4851	}
4852
4853
4854	[TestFixture]
4855	public class MappingTestAgrBinnOthpconTblGuid : NDOTest
4856	{
4857	····PersistenceManager pm;
4858	····NDOMapping mapping;
4859	····Class ownClass;
4860	····Class otherClass;
4861	····Class otherDerivedClass;
4862	····[SetUp]
4863	····public void Setup()
4864	····{
4865	········this.pm = PmFactory.NewPersistenceManager();
4866	········this.mapping = pm.NDOMapping;
4867	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidLeft" );
4868	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidRightBase" );
4869	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpconTblGuidRightDerived" );
4870	····}
4871	····[Test]
4872	····public void HasMappingTable()
4873	····{
4874	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4875	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
4876	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
4877	····}
4878	····[Test]
4879	····public void HasTypeColumn()
4880	····{
4881	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
4882	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
4883	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
4884	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4885	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
4886	····}
4887	····[Test]
4888	····public void HasTypeCode()
4889	····{
4890	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4891	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4892	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4893	····}
4894	}
4895
4896
4897	[TestFixture]
4898	public class MappingTestCmpDir1OthpconNoTblGuid : NDOTest
4899	{
4900	····PersistenceManager pm;
4901	····NDOMapping mapping;
4902	····Class ownClass;
4903	····Class otherClass;
4904	····Class otherDerivedClass;
4905	····[SetUp]
4906	····public void Setup()
4907	····{
4908	········this.pm = PmFactory.NewPersistenceManager();
4909	········this.mapping = pm.NDOMapping;
4910	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidLeft" );
4911	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidRightBase" );
4912	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconNoTblGuidRightDerived" );
4913	····}
4914	····[Test]
4915	····public void HasMappingTable()
4916	····{
4917	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4918	····}
4919	····[Test]
4920	····public void HasTypeColumn()
4921	····{
4922	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
4923	····}
4924	····[Test]
4925	····public void HasTypeCode()
4926	····{
4927	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4928	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4929	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4930	····}
4931	}
4932
4933
4934	[TestFixture]
4935	public class MappingTestCmpDir1OthpconTblGuid : NDOTest
4936	{
4937	····PersistenceManager pm;
4938	····NDOMapping mapping;
4939	····Class ownClass;
4940	····Class otherClass;
4941	····Class otherDerivedClass;
4942	····[SetUp]
4943	····public void Setup()
4944	····{
4945	········this.pm = PmFactory.NewPersistenceManager();
4946	········this.mapping = pm.NDOMapping;
4947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidLeft" );
4948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidRightBase" );
4949	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpconTblGuidRightDerived" );
4950	····}
4951	····[Test]
4952	····public void HasMappingTable()
4953	····{
4954	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
4955	····}
4956	····[Test]
4957	····public void HasTypeColumn()
4958	····{
4959	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
4960	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
4961	····}
4962	····[Test]
4963	····public void HasTypeCode()
4964	····{
4965	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
4966	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
4967	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
4968	····}
4969	}
4970
4971
4972	[TestFixture]
4973	public class MappingTestCmpBi11OthpconNoTblGuid : NDOTest
4974	{
4975	····PersistenceManager pm;
4976	····NDOMapping mapping;
4977	····Class ownClass;
4978	····Class otherClass;
4979	····Class otherDerivedClass;
4980	····[SetUp]
4981	····public void Setup()
4982	····{
4983	········this.pm = PmFactory.NewPersistenceManager();
4984	········this.mapping = pm.NDOMapping;
4985	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidLeft" );
4986	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidRightBase" );
4987	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconNoTblGuidRightDerived" );
4988	····}
4989	····[Test]
4990	····public void HasMappingTable()
4991	····{
4992	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
4993	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
4994	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
4995	····}
4996	····[Test]
4997	····public void HasTypeColumn()
4998	····{
4999	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
5000	····}
5001	····[Test]
5002	····public void HasTypeCode()
5003	····{
5004	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5005	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5006	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5007	····}
5008	}
5009
5010
5011	[TestFixture]
5012	public class MappingTestCmpBi11OthpconTblGuid : NDOTest
5013	{
5014	····PersistenceManager pm;
5015	····NDOMapping mapping;
5016	····Class ownClass;
5017	····Class otherClass;
5018	····Class otherDerivedClass;
5019	····[SetUp]
5020	····public void Setup()
5021	····{
5022	········this.pm = PmFactory.NewPersistenceManager();
5023	········this.mapping = pm.NDOMapping;
5024	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidLeft" );
5025	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidRightBase" );
5026	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpconTblGuidRightDerived" );
5027	····}
5028	····[Test]
5029	····public void HasMappingTable()
5030	····{
5031	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5032	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5033	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5034	····}
5035	····[Test]
5036	····public void HasTypeColumn()
5037	····{
5038	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5039	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5040	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5041	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
5042	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
5043	····}
5044	····[Test]
5045	····public void HasTypeCode()
5046	····{
5047	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5048	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5049	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5050	····}
5051	}
5052
5053
5054	[TestFixture]
5055	public class MappingTestCmpDirnOthpconTblGuid : NDOTest
5056	{
5057	····PersistenceManager pm;
5058	····NDOMapping mapping;
5059	····Class ownClass;
5060	····Class otherClass;
5061	····Class otherDerivedClass;
5062	····[SetUp]
5063	····public void Setup()
5064	····{
5065	········this.pm = PmFactory.NewPersistenceManager();
5066	········this.mapping = pm.NDOMapping;
5067	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidLeft" );
5068	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidRightBase" );
5069	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpconTblGuidRightDerived" );
5070	····}
5071	····[Test]
5072	····public void HasMappingTable()
5073	····{
5074	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5075	····}
5076	····[Test]
5077	····public void HasTypeColumn()
5078	····{
5079	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5080	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
5081	····}
5082	····[Test]
5083	····public void HasTypeCode()
5084	····{
5085	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5086	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5087	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5088	····}
5089	}
5090
5091
5092	[TestFixture]
5093	public class MappingTestCmpBin1OthpconTblGuid : NDOTest
5094	{
5095	····PersistenceManager pm;
5096	····NDOMapping mapping;
5097	····Class ownClass;
5098	····Class otherClass;
5099	····Class otherDerivedClass;
5100	····[SetUp]
5101	····public void Setup()
5102	····{
5103	········this.pm = PmFactory.NewPersistenceManager();
5104	········this.mapping = pm.NDOMapping;
5105	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidLeft" );
5106	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidRightBase" );
5107	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpconTblGuidRightDerived" );
5108	····}
5109	····[Test]
5110	····public void HasMappingTable()
5111	····{
5112	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5113	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5114	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5115	····}
5116	····[Test]
5117	····public void HasTypeColumn()
5118	····{
5119	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5120	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5121	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5122	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
5123	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
5124	····}
5125	····[Test]
5126	····public void HasTypeCode()
5127	····{
5128	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5129	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5130	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5131	····}
5132	}
5133
5134
5135	[TestFixture]
5136	public class MappingTestCmpBi1nOthpconNoTblGuid : NDOTest
5137	{
5138	····PersistenceManager pm;
5139	····NDOMapping mapping;
5140	····Class ownClass;
5141	····Class otherClass;
5142	····Class otherDerivedClass;
5143	····[SetUp]
5144	····public void Setup()
5145	····{
5146	········this.pm = PmFactory.NewPersistenceManager();
5147	········this.mapping = pm.NDOMapping;
5148	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidLeft" );
5149	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidRightBase" );
5150	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconNoTblGuidRightDerived" );
5151	····}
5152	····[Test]
5153	····public void HasMappingTable()
5154	····{
5155	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
5156	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
5157	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
5158	····}
5159	····[Test]
5160	····public void HasTypeColumn()
5161	····{
5162	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
5163	····}
5164	····[Test]
5165	····public void HasTypeCode()
5166	····{
5167	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5168	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5169	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5170	····}
5171	}
5172
5173
5174	[TestFixture]
5175	public class MappingTestCmpBi1nOthpconTblGuid : NDOTest
5176	{
5177	····PersistenceManager pm;
5178	····NDOMapping mapping;
5179	····Class ownClass;
5180	····Class otherClass;
5181	····Class otherDerivedClass;
5182	····[SetUp]
5183	····public void Setup()
5184	····{
5185	········this.pm = PmFactory.NewPersistenceManager();
5186	········this.mapping = pm.NDOMapping;
5187	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidLeft" );
5188	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidRightBase" );
5189	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpconTblGuidRightDerived" );
5190	····}
5191	····[Test]
5192	····public void HasMappingTable()
5193	····{
5194	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5195	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5196	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5197	····}
5198	····[Test]
5199	····public void HasTypeColumn()
5200	····{
5201	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5202	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5203	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5204	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
5205	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
5206	····}
5207	····[Test]
5208	····public void HasTypeCode()
5209	····{
5210	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5211	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5212	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5213	····}
5214	}
5215
5216
5217	[TestFixture]
5218	public class MappingTestCmpBinnOthpconTblGuid : NDOTest
5219	{
5220	····PersistenceManager pm;
5221	····NDOMapping mapping;
5222	····Class ownClass;
5223	····Class otherClass;
5224	····Class otherDerivedClass;
5225	····[SetUp]
5226	····public void Setup()
5227	····{
5228	········this.pm = PmFactory.NewPersistenceManager();
5229	········this.mapping = pm.NDOMapping;
5230	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidLeft" );
5231	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidRightBase" );
5232	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpconTblGuidRightDerived" );
5233	····}
5234	····[Test]
5235	····public void HasMappingTable()
5236	····{
5237	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5238	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5239	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5240	····}
5241	····[Test]
5242	····public void HasTypeColumn()
5243	····{
5244	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5245	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5246	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5247	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
5248	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
5249	····}
5250	····[Test]
5251	····public void HasTypeCode()
5252	····{
5253	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5254	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5255	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5256	····}
5257	}
5258
5259
5260	[TestFixture]
5261	public class MappingTestAgrDir1OwnpconOthpconNoTblGuid : NDOTest
5262	{
5263	····PersistenceManager pm;
5264	····NDOMapping mapping;
5265	····Class ownClass;
5266	····Class otherClass;
5267	····Class ownDerivedClass;
5268	····Class otherDerivedClass;
5269	····[SetUp]
5270	····public void Setup()
5271	····{
5272	········this.pm = PmFactory.NewPersistenceManager();
5273	········this.mapping = pm.NDOMapping;
5274	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidLeftBase" );
5275	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidRightBase" );
5276	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidLeftDerived" );
5277	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconNoTblGuidRightDerived" );
5278	····}
5279	····[Test]
5280	····public void HasMappingTable()
5281	····{
5282	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
5283	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
5284	····}
5285	····[Test]
5286	····public void HasTypeColumn()
5287	····{
5288	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
5289	····}
5290	····[Test]
5291	····public void HasTypeCode()
5292	····{
5293	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5294	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5295	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5296	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5297	····}
5298	}
5299
5300
5301	[TestFixture]
5302	public class MappingTestAgrDir1OwnpconOthpconTblGuid : NDOTest
5303	{
5304	····PersistenceManager pm;
5305	····NDOMapping mapping;
5306	····Class ownClass;
5307	····Class otherClass;
5308	····Class ownDerivedClass;
5309	····Class otherDerivedClass;
5310	····[SetUp]
5311	····public void Setup()
5312	····{
5313	········this.pm = PmFactory.NewPersistenceManager();
5314	········this.mapping = pm.NDOMapping;
5315	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidLeftBase" );
5316	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidRightBase" );
5317	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidLeftDerived" );
5318	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpconOthpconTblGuidRightDerived" );
5319	····}
5320	····[Test]
5321	····public void HasMappingTable()
5322	····{
5323	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5324	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5325	····}
5326	····[Test]
5327	····public void HasTypeColumn()
5328	····{
5329	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5330	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5331	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5332	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5333	····}
5334	····[Test]
5335	····public void HasTypeCode()
5336	····{
5337	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5338	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5339	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5340	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5341	····}
5342	}
5343
5344
5345	[TestFixture]
5346	public class MappingTestAgrBi11OwnpconOthpconNoTblGuid : NDOTest
5347	{
5348	····PersistenceManager pm;
5349	····NDOMapping mapping;
5350	····Class ownClass;
5351	····Class otherClass;
5352	····Class ownDerivedClass;
5353	····Class otherDerivedClass;
5354	····[SetUp]
5355	····public void Setup()
5356	····{
5357	········this.pm = PmFactory.NewPersistenceManager();
5358	········this.mapping = pm.NDOMapping;
5359	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidLeftBase" );
5360	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidRightBase" );
5361	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidLeftDerived" );
5362	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconNoTblGuidRightDerived" );
5363	····}
5364	····[Test]
5365	····public void HasMappingTable()
5366	····{
5367	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
5368	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
5369	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
5370	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
5371	····}
5372	····[Test]
5373	····public void HasTypeColumn()
5374	····{
5375	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
5376	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
5377	····}
5378	····[Test]
5379	····public void HasTypeCode()
5380	····{
5381	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5382	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5383	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5384	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5385	····}
5386	}
5387
5388
5389	[TestFixture]
5390	public class MappingTestAgrBi11OwnpconOthpconTblGuid : NDOTest
5391	{
5392	····PersistenceManager pm;
5393	····NDOMapping mapping;
5394	····Class ownClass;
5395	····Class otherClass;
5396	····Class ownDerivedClass;
5397	····Class otherDerivedClass;
5398	····[SetUp]
5399	····public void Setup()
5400	····{
5401	········this.pm = PmFactory.NewPersistenceManager();
5402	········this.mapping = pm.NDOMapping;
5403	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidLeftBase" );
5404	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidRightBase" );
5405	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidLeftDerived" );
5406	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpconOthpconTblGuidRightDerived" );
5407	····}
5408	····[Test]
5409	····public void HasMappingTable()
5410	····{
5411	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5412	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5413	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5414	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5415	····}
5416	····[Test]
5417	····public void HasTypeColumn()
5418	····{
5419	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5420	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5421	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5422	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5423	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5424	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5425	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
5426	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
5427	····}
5428	····[Test]
5429	····public void HasTypeCode()
5430	····{
5431	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5432	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5433	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5434	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5435	····}
5436	}
5437
5438
5439	[TestFixture]
5440	public class MappingTestAgrDirnOwnpconOthpconTblGuid : NDOTest
5441	{
5442	····PersistenceManager pm;
5443	····NDOMapping mapping;
5444	····Class ownClass;
5445	····Class otherClass;
5446	····Class ownDerivedClass;
5447	····Class otherDerivedClass;
5448	····[SetUp]
5449	····public void Setup()
5450	····{
5451	········this.pm = PmFactory.NewPersistenceManager();
5452	········this.mapping = pm.NDOMapping;
5453	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidLeftBase" );
5454	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidRightBase" );
5455	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidLeftDerived" );
5456	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpconOthpconTblGuidRightDerived" );
5457	····}
5458	····[Test]
5459	····public void HasMappingTable()
5460	····{
5461	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5462	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5463	····}
5464	····[Test]
5465	····public void HasTypeColumn()
5466	····{
5467	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5468	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5469	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5470	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5471	····}
5472	····[Test]
5473	····public void HasTypeCode()
5474	····{
5475	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5476	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5477	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5478	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5479	····}
5480	}
5481
5482
5483	[TestFixture]
5484	public class MappingTestAgrBin1OwnpconOthpconTblGuid : NDOTest
5485	{
5486	····PersistenceManager pm;
5487	····NDOMapping mapping;
5488	····Class ownClass;
5489	····Class otherClass;
5490	····Class ownDerivedClass;
5491	····Class otherDerivedClass;
5492	····[SetUp]
5493	····public void Setup()
5494	····{
5495	········this.pm = PmFactory.NewPersistenceManager();
5496	········this.mapping = pm.NDOMapping;
5497	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidLeftBase" );
5498	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidRightBase" );
5499	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidLeftDerived" );
5500	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpconOthpconTblGuidRightDerived" );
5501	····}
5502	····[Test]
5503	····public void HasMappingTable()
5504	····{
5505	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5506	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5507	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5508	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5509	····}
5510	····[Test]
5511	····public void HasTypeColumn()
5512	····{
5513	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5514	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5515	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5516	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5517	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5518	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5519	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
5520	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
5521	····}
5522	····[Test]
5523	····public void HasTypeCode()
5524	····{
5525	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5526	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5527	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5528	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5529	····}
5530	}
5531
5532
5533	[TestFixture]
5534	public class MappingTestAgrBi1nOwnpconOthpconTblGuid : NDOTest
5535	{
5536	····PersistenceManager pm;
5537	····NDOMapping mapping;
5538	····Class ownClass;
5539	····Class otherClass;
5540	····Class ownDerivedClass;
5541	····Class otherDerivedClass;
5542	····[SetUp]
5543	····public void Setup()
5544	····{
5545	········this.pm = PmFactory.NewPersistenceManager();
5546	········this.mapping = pm.NDOMapping;
5547	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidLeftBase" );
5548	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidRightBase" );
5549	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidLeftDerived" );
5550	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpconOthpconTblGuidRightDerived" );
5551	····}
5552	····[Test]
5553	····public void HasMappingTable()
5554	····{
5555	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5556	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5557	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5558	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5559	····}
5560	····[Test]
5561	····public void HasTypeColumn()
5562	····{
5563	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5564	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5565	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5566	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5567	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5568	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5569	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
5570	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
5571	····}
5572	····[Test]
5573	····public void HasTypeCode()
5574	····{
5575	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5576	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5577	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5578	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5579	····}
5580	}
5581
5582
5583	[TestFixture]
5584	public class MappingTestAgrBinnOwnpconOthpconTblGuid : NDOTest
5585	{
5586	····PersistenceManager pm;
5587	····NDOMapping mapping;
5588	····Class ownClass;
5589	····Class otherClass;
5590	····Class ownDerivedClass;
5591	····Class otherDerivedClass;
5592	····[SetUp]
5593	····public void Setup()
5594	····{
5595	········this.pm = PmFactory.NewPersistenceManager();
5596	········this.mapping = pm.NDOMapping;
5597	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidLeftBase" );
5598	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidRightBase" );
5599	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidLeftDerived" );
5600	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpconOthpconTblGuidRightDerived" );
5601	····}
5602	····[Test]
5603	····public void HasMappingTable()
5604	····{
5605	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5606	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5607	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5608	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5609	····}
5610	····[Test]
5611	····public void HasTypeColumn()
5612	····{
5613	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5614	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5615	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5616	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5617	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5618	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5619	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
5620	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
5621	····}
5622	····[Test]
5623	····public void HasTypeCode()
5624	····{
5625	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5626	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5627	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5628	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5629	····}
5630	}
5631
5632
5633	[TestFixture]
5634	public class MappingTestCmpDir1OwnpconOthpconNoTblGuid : NDOTest
5635	{
5636	····PersistenceManager pm;
5637	····NDOMapping mapping;
5638	····Class ownClass;
5639	····Class otherClass;
5640	····Class ownDerivedClass;
5641	····Class otherDerivedClass;
5642	····[SetUp]
5643	····public void Setup()
5644	····{
5645	········this.pm = PmFactory.NewPersistenceManager();
5646	········this.mapping = pm.NDOMapping;
5647	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidLeftBase" );
5648	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidRightBase" );
5649	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidLeftDerived" );
5650	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconNoTblGuidRightDerived" );
5651	····}
5652	····[Test]
5653	····public void HasMappingTable()
5654	····{
5655	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
5656	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
5657	····}
5658	····[Test]
5659	····public void HasTypeColumn()
5660	····{
5661	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
5662	····}
5663	····[Test]
5664	····public void HasTypeCode()
5665	····{
5666	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5667	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5668	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5669	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5670	····}
5671	}
5672
5673
5674	[TestFixture]
5675	public class MappingTestCmpDir1OwnpconOthpconTblGuid : NDOTest
5676	{
5677	····PersistenceManager pm;
5678	····NDOMapping mapping;
5679	····Class ownClass;
5680	····Class otherClass;
5681	····Class ownDerivedClass;
5682	····Class otherDerivedClass;
5683	····[SetUp]
5684	····public void Setup()
5685	····{
5686	········this.pm = PmFactory.NewPersistenceManager();
5687	········this.mapping = pm.NDOMapping;
5688	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidLeftBase" );
5689	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidRightBase" );
5690	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidLeftDerived" );
5691	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpconOthpconTblGuidRightDerived" );
5692	····}
5693	····[Test]
5694	····public void HasMappingTable()
5695	····{
5696	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5697	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5698	····}
5699	····[Test]
5700	····public void HasTypeColumn()
5701	····{
5702	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5703	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5704	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5705	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5706	····}
5707	····[Test]
5708	····public void HasTypeCode()
5709	····{
5710	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5711	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5712	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5713	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5714	····}
5715	}
5716
5717
5718	[TestFixture]
5719	public class MappingTestCmpBi11OwnpconOthpconNoTblGuid : NDOTest
5720	{
5721	····PersistenceManager pm;
5722	····NDOMapping mapping;
5723	····Class ownClass;
5724	····Class otherClass;
5725	····Class ownDerivedClass;
5726	····Class otherDerivedClass;
5727	····[SetUp]
5728	····public void Setup()
5729	····{
5730	········this.pm = PmFactory.NewPersistenceManager();
5731	········this.mapping = pm.NDOMapping;
5732	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidLeftBase" );
5733	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidRightBase" );
5734	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidLeftDerived" );
5735	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconNoTblGuidRightDerived" );
5736	····}
5737	····[Test]
5738	····public void HasMappingTable()
5739	····{
5740	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
5741	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
5742	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
5743	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
5744	····}
5745	····[Test]
5746	····public void HasTypeColumn()
5747	····{
5748	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
5749	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
5750	····}
5751	····[Test]
5752	····public void HasTypeCode()
5753	····{
5754	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5755	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5756	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5757	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5758	····}
5759	}
5760
5761
5762	[TestFixture]
5763	public class MappingTestCmpBi11OwnpconOthpconTblGuid : NDOTest
5764	{
5765	····PersistenceManager pm;
5766	····NDOMapping mapping;
5767	····Class ownClass;
5768	····Class otherClass;
5769	····Class ownDerivedClass;
5770	····Class otherDerivedClass;
5771	····[SetUp]
5772	····public void Setup()
5773	····{
5774	········this.pm = PmFactory.NewPersistenceManager();
5775	········this.mapping = pm.NDOMapping;
5776	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidLeftBase" );
5777	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidRightBase" );
5778	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidLeftDerived" );
5779	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpconOthpconTblGuidRightDerived" );
5780	····}
5781	····[Test]
5782	····public void HasMappingTable()
5783	····{
5784	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5785	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5786	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5787	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5788	····}
5789	····[Test]
5790	····public void HasTypeColumn()
5791	····{
5792	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5793	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5794	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5795	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5796	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5797	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5798	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
5799	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
5800	····}
5801	····[Test]
5802	····public void HasTypeCode()
5803	····{
5804	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5805	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5806	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5807	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5808	····}
5809	}
5810
5811
5812	[TestFixture]
5813	public class MappingTestCmpDirnOwnpconOthpconTblGuid : NDOTest
5814	{
5815	····PersistenceManager pm;
5816	····NDOMapping mapping;
5817	····Class ownClass;
5818	····Class otherClass;
5819	····Class ownDerivedClass;
5820	····Class otherDerivedClass;
5821	····[SetUp]
5822	····public void Setup()
5823	····{
5824	········this.pm = PmFactory.NewPersistenceManager();
5825	········this.mapping = pm.NDOMapping;
5826	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidLeftBase" );
5827	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidRightBase" );
5828	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidLeftDerived" );
5829	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpconOthpconTblGuidRightDerived" );
5830	····}
5831	····[Test]
5832	····public void HasMappingTable()
5833	····{
5834	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5835	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5836	····}
5837	····[Test]
5838	····public void HasTypeColumn()
5839	····{
5840	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5841	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5842	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5843	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5844	····}
5845	····[Test]
5846	····public void HasTypeCode()
5847	····{
5848	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5849	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5850	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5851	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5852	····}
5853	}
5854
5855
5856	[TestFixture]
5857	public class MappingTestCmpBin1OwnpconOthpconTblGuid : NDOTest
5858	{
5859	····PersistenceManager pm;
5860	····NDOMapping mapping;
5861	····Class ownClass;
5862	····Class otherClass;
5863	····Class ownDerivedClass;
5864	····Class otherDerivedClass;
5865	····[SetUp]
5866	····public void Setup()
5867	····{
5868	········this.pm = PmFactory.NewPersistenceManager();
5869	········this.mapping = pm.NDOMapping;
5870	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidLeftBase" );
5871	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidRightBase" );
5872	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidLeftDerived" );
5873	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpconOthpconTblGuidRightDerived" );
5874	····}
5875	····[Test]
5876	····public void HasMappingTable()
5877	····{
5878	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5879	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5880	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5881	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5882	····}
5883	····[Test]
5884	····public void HasTypeColumn()
5885	····{
5886	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5887	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5888	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5889	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5890	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5891	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5892	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
5893	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
5894	····}
5895	····[Test]
5896	····public void HasTypeCode()
5897	····{
5898	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5899	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5900	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5901	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5902	····}
5903	}
5904
5905
5906	[TestFixture]
5907	public class MappingTestCmpBi1nOwnpconOthpconTblGuid : NDOTest
5908	{
5909	····PersistenceManager pm;
5910	····NDOMapping mapping;
5911	····Class ownClass;
5912	····Class otherClass;
5913	····Class ownDerivedClass;
5914	····Class otherDerivedClass;
5915	····[SetUp]
5916	····public void Setup()
5917	····{
5918	········this.pm = PmFactory.NewPersistenceManager();
5919	········this.mapping = pm.NDOMapping;
5920	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidLeftBase" );
5921	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidRightBase" );
5922	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidLeftDerived" );
5923	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpconOthpconTblGuidRightDerived" );
5924	····}
5925	····[Test]
5926	····public void HasMappingTable()
5927	····{
5928	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5929	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5930	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5931	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5932	····}
5933	····[Test]
5934	····public void HasTypeColumn()
5935	····{
5936	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5937	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5938	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5939	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5940	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5941	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5942	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
5943	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
5944	····}
5945	····[Test]
5946	····public void HasTypeCode()
5947	····{
5948	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5949	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
5950	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
5951	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
5952	····}
5953	}
5954
5955
5956	[TestFixture]
5957	public class MappingTestCmpBinnOwnpconOthpconTblGuid : NDOTest
5958	{
5959	····PersistenceManager pm;
5960	····NDOMapping mapping;
5961	····Class ownClass;
5962	····Class otherClass;
5963	····Class ownDerivedClass;
5964	····Class otherDerivedClass;
5965	····[SetUp]
5966	····public void Setup()
5967	····{
5968	········this.pm = PmFactory.NewPersistenceManager();
5969	········this.mapping = pm.NDOMapping;
5970	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidLeftBase" );
5971	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidRightBase" );
5972	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidLeftDerived" );
5973	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpconOthpconTblGuidRightDerived" );
5974	····}
5975	····[Test]
5976	····public void HasMappingTable()
5977	····{
5978	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
5979	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
5980	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
5981	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
5982	····}
5983	····[Test]
5984	····public void HasTypeColumn()
5985	····{
5986	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
5987	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
5988	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
5989	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
5990	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
5991	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
5992	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
5993	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
5994	····}
5995	····[Test]
5996	····public void HasTypeCode()
5997	····{
5998	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
5999	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6000	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6001	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6002	····}
6003	}
6004
6005
6006	[TestFixture]
6007	public class MappingTestAgrDir1OwnpabsNoTblAuto : NDOTest
6008	{
6009	····PersistenceManager pm;
6010	····NDOMapping mapping;
6011	····Class ownClass;
6012	····Class otherClass;
6013	····Class ownDerivedClass;
6014	····[SetUp]
6015	····public void Setup()
6016	····{
6017	········this.pm = PmFactory.NewPersistenceManager();
6018	········this.mapping = pm.NDOMapping;
6019	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoLeftBase" );
6020	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoRight" );
6021	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblAutoLeftDerived" );
6022	····}
6023	····[Test]
6024	····public void HasMappingTable()
6025	····{
6026	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6027	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
6028	····}
6029	····[Test]
6030	····public void HasTypeColumn()
6031	····{
6032	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6033	····}
6034	····[Test]
6035	····public void HasTypeCode()
6036	····{
6037	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6038	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6039	····}
6040	}
6041
6042
6043	[TestFixture]
6044	public class MappingTestAgrDir1OwnpabsTblAuto : NDOTest
6045	{
6046	····PersistenceManager pm;
6047	····NDOMapping mapping;
6048	····Class ownClass;
6049	····Class otherClass;
6050	····Class ownDerivedClass;
6051	····[SetUp]
6052	····public void Setup()
6053	····{
6054	········this.pm = PmFactory.NewPersistenceManager();
6055	········this.mapping = pm.NDOMapping;
6056	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoLeftBase" );
6057	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoRight" );
6058	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblAutoLeftDerived" );
6059	····}
6060	····[Test]
6061	····public void HasMappingTable()
6062	····{
6063	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6064	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6065	····}
6066	····[Test]
6067	····public void HasTypeColumn()
6068	····{
6069	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6070	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6071	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6072	····}
6073	····[Test]
6074	····public void HasTypeCode()
6075	····{
6076	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6077	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6078	····}
6079	}
6080
6081
6082	[TestFixture]
6083	public class MappingTestAgrBi11OwnpabsNoTblAuto : NDOTest
6084	{
6085	····PersistenceManager pm;
6086	····NDOMapping mapping;
6087	····Class ownClass;
6088	····Class otherClass;
6089	····Class ownDerivedClass;
6090	····[SetUp]
6091	····public void Setup()
6092	····{
6093	········this.pm = PmFactory.NewPersistenceManager();
6094	········this.mapping = pm.NDOMapping;
6095	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoLeftBase" );
6096	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoRight" );
6097	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblAutoLeftDerived" );
6098	····}
6099	····[Test]
6100	····public void HasMappingTable()
6101	····{
6102	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6103	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
6104	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
6105	····}
6106	····[Test]
6107	····public void HasTypeColumn()
6108	····{
6109	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6110	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
6111	····}
6112	····[Test]
6113	····public void HasTypeCode()
6114	····{
6115	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6116	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6117	····}
6118	}
6119
6120
6121	[TestFixture]
6122	public class MappingTestAgrBi11OwnpabsTblAuto : NDOTest
6123	{
6124	····PersistenceManager pm;
6125	····NDOMapping mapping;
6126	····Class ownClass;
6127	····Class otherClass;
6128	····Class ownDerivedClass;
6129	····[SetUp]
6130	····public void Setup()
6131	····{
6132	········this.pm = PmFactory.NewPersistenceManager();
6133	········this.mapping = pm.NDOMapping;
6134	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoLeftBase" );
6135	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoRight" );
6136	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblAutoLeftDerived" );
6137	····}
6138	····[Test]
6139	····public void HasMappingTable()
6140	····{
6141	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6142	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6143	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6144	····}
6145	····[Test]
6146	····public void HasTypeColumn()
6147	····{
6148	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6149	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6150	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
6151	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6152	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
6153	····}
6154	····[Test]
6155	····public void HasTypeCode()
6156	····{
6157	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6158	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6159	····}
6160	}
6161
6162
6163	[TestFixture]
6164	public class MappingTestAgrDirnOwnpabsNoTblAuto : NDOTest
6165	{
6166	····PersistenceManager pm;
6167	····NDOMapping mapping;
6168	····Class ownClass;
6169	····Class otherClass;
6170	····Class ownDerivedClass;
6171	····[SetUp]
6172	····public void Setup()
6173	····{
6174	········this.pm = PmFactory.NewPersistenceManager();
6175	········this.mapping = pm.NDOMapping;
6176	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoLeftBase" );
6177	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoRight" );
6178	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblAutoLeftDerived" );
6179	····}
6180	····[Test]
6181	····public void HasMappingTable()
6182	····{
6183	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6184	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
6185	····}
6186	····[Test]
6187	····public void HasTypeColumn()
6188	····{
6189	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6190	····}
6191	····[Test]
6192	····public void HasTypeCode()
6193	····{
6194	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6195	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6196	····}
6197	}
6198
6199
6200	[TestFixture]
6201	public class MappingTestAgrDirnOwnpabsTblAuto : NDOTest
6202	{
6203	····PersistenceManager pm;
6204	····NDOMapping mapping;
6205	····Class ownClass;
6206	····Class otherClass;
6207	····Class ownDerivedClass;
6208	····[SetUp]
6209	····public void Setup()
6210	····{
6211	········this.pm = PmFactory.NewPersistenceManager();
6212	········this.mapping = pm.NDOMapping;
6213	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoLeftBase" );
6214	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoRight" );
6215	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblAutoLeftDerived" );
6216	····}
6217	····[Test]
6218	····public void HasMappingTable()
6219	····{
6220	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6221	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6222	····}
6223	····[Test]
6224	····public void HasTypeColumn()
6225	····{
6226	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6227	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6228	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6229	····}
6230	····[Test]
6231	····public void HasTypeCode()
6232	····{
6233	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6234	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6235	····}
6236	}
6237
6238
6239	[TestFixture]
6240	public class MappingTestAgrBin1OwnpabsNoTblAuto : NDOTest
6241	{
6242	····PersistenceManager pm;
6243	····NDOMapping mapping;
6244	····Class ownClass;
6245	····Class otherClass;
6246	····Class ownDerivedClass;
6247	····[SetUp]
6248	····public void Setup()
6249	····{
6250	········this.pm = PmFactory.NewPersistenceManager();
6251	········this.mapping = pm.NDOMapping;
6252	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoLeftBase" );
6253	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoRight" );
6254	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblAutoLeftDerived" );
6255	····}
6256	····[Test]
6257	····public void HasMappingTable()
6258	····{
6259	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6260	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
6261	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
6262	····}
6263	····[Test]
6264	····public void HasTypeColumn()
6265	····{
6266	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6267	····}
6268	····[Test]
6269	····public void HasTypeCode()
6270	····{
6271	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6272	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6273	····}
6274	}
6275
6276
6277	[TestFixture]
6278	public class MappingTestAgrBin1OwnpabsTblAuto : NDOTest
6279	{
6280	····PersistenceManager pm;
6281	····NDOMapping mapping;
6282	····Class ownClass;
6283	····Class otherClass;
6284	····Class ownDerivedClass;
6285	····[SetUp]
6286	····public void Setup()
6287	····{
6288	········this.pm = PmFactory.NewPersistenceManager();
6289	········this.mapping = pm.NDOMapping;
6290	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoLeftBase" );
6291	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoRight" );
6292	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblAutoLeftDerived" );
6293	····}
6294	····[Test]
6295	····public void HasMappingTable()
6296	····{
6297	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6298	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6299	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6300	····}
6301	····[Test]
6302	····public void HasTypeColumn()
6303	····{
6304	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6305	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6306	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
6307	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6308	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
6309	····}
6310	····[Test]
6311	····public void HasTypeCode()
6312	····{
6313	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6314	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6315	····}
6316	}
6317
6318
6319	[TestFixture]
6320	public class MappingTestAgrBi1nOwnpabsTblAuto : NDOTest
6321	{
6322	····PersistenceManager pm;
6323	····NDOMapping mapping;
6324	····Class ownClass;
6325	····Class otherClass;
6326	····Class ownDerivedClass;
6327	····[SetUp]
6328	····public void Setup()
6329	····{
6330	········this.pm = PmFactory.NewPersistenceManager();
6331	········this.mapping = pm.NDOMapping;
6332	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoLeftBase" );
6333	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoRight" );
6334	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblAutoLeftDerived" );
6335	····}
6336	····[Test]
6337	····public void HasMappingTable()
6338	····{
6339	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6340	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6341	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6342	····}
6343	····[Test]
6344	····public void HasTypeColumn()
6345	····{
6346	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6347	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6348	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
6349	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6350	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
6351	····}
6352	····[Test]
6353	····public void HasTypeCode()
6354	····{
6355	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6356	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6357	····}
6358	}
6359
6360
6361	[TestFixture]
6362	public class MappingTestAgrBinnOwnpabsTblAuto : NDOTest
6363	{
6364	····PersistenceManager pm;
6365	····NDOMapping mapping;
6366	····Class ownClass;
6367	····Class otherClass;
6368	····Class ownDerivedClass;
6369	····[SetUp]
6370	····public void Setup()
6371	····{
6372	········this.pm = PmFactory.NewPersistenceManager();
6373	········this.mapping = pm.NDOMapping;
6374	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoLeftBase" );
6375	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoRight" );
6376	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblAutoLeftDerived" );
6377	····}
6378	····[Test]
6379	····public void HasMappingTable()
6380	····{
6381	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6382	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6383	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6384	····}
6385	····[Test]
6386	····public void HasTypeColumn()
6387	····{
6388	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6389	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6390	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
6391	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6392	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
6393	····}
6394	····[Test]
6395	····public void HasTypeCode()
6396	····{
6397	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6398	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6399	····}
6400	}
6401
6402
6403	[TestFixture]
6404	public class MappingTestCmpDir1OwnpabsNoTblAuto : NDOTest
6405	{
6406	····PersistenceManager pm;
6407	····NDOMapping mapping;
6408	····Class ownClass;
6409	····Class otherClass;
6410	····Class ownDerivedClass;
6411	····[SetUp]
6412	····public void Setup()
6413	····{
6414	········this.pm = PmFactory.NewPersistenceManager();
6415	········this.mapping = pm.NDOMapping;
6416	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoLeftBase" );
6417	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoRight" );
6418	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblAutoLeftDerived" );
6419	····}
6420	····[Test]
6421	····public void HasMappingTable()
6422	····{
6423	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6424	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
6425	····}
6426	····[Test]
6427	····public void HasTypeColumn()
6428	····{
6429	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6430	····}
6431	····[Test]
6432	····public void HasTypeCode()
6433	····{
6434	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6435	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6436	····}
6437	}
6438
6439
6440	[TestFixture]
6441	public class MappingTestCmpDir1OwnpabsTblAuto : NDOTest
6442	{
6443	····PersistenceManager pm;
6444	····NDOMapping mapping;
6445	····Class ownClass;
6446	····Class otherClass;
6447	····Class ownDerivedClass;
6448	····[SetUp]
6449	····public void Setup()
6450	····{
6451	········this.pm = PmFactory.NewPersistenceManager();
6452	········this.mapping = pm.NDOMapping;
6453	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoLeftBase" );
6454	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoRight" );
6455	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblAutoLeftDerived" );
6456	····}
6457	····[Test]
6458	····public void HasMappingTable()
6459	····{
6460	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6461	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6462	····}
6463	····[Test]
6464	····public void HasTypeColumn()
6465	····{
6466	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6467	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6468	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6469	····}
6470	····[Test]
6471	····public void HasTypeCode()
6472	····{
6473	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6474	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6475	····}
6476	}
6477
6478
6479	[TestFixture]
6480	public class MappingTestCmpBi11OwnpabsNoTblAuto : NDOTest
6481	{
6482	····PersistenceManager pm;
6483	····NDOMapping mapping;
6484	····Class ownClass;
6485	····Class otherClass;
6486	····Class ownDerivedClass;
6487	····[SetUp]
6488	····public void Setup()
6489	····{
6490	········this.pm = PmFactory.NewPersistenceManager();
6491	········this.mapping = pm.NDOMapping;
6492	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoLeftBase" );
6493	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoRight" );
6494	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblAutoLeftDerived" );
6495	····}
6496	····[Test]
6497	····public void HasMappingTable()
6498	····{
6499	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6500	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
6501	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
6502	····}
6503	····[Test]
6504	····public void HasTypeColumn()
6505	····{
6506	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6507	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
6508	····}
6509	····[Test]
6510	····public void HasTypeCode()
6511	····{
6512	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6513	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6514	····}
6515	}
6516
6517
6518	[TestFixture]
6519	public class MappingTestCmpBi11OwnpabsTblAuto : NDOTest
6520	{
6521	····PersistenceManager pm;
6522	····NDOMapping mapping;
6523	····Class ownClass;
6524	····Class otherClass;
6525	····Class ownDerivedClass;
6526	····[SetUp]
6527	····public void Setup()
6528	····{
6529	········this.pm = PmFactory.NewPersistenceManager();
6530	········this.mapping = pm.NDOMapping;
6531	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoLeftBase" );
6532	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoRight" );
6533	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblAutoLeftDerived" );
6534	····}
6535	····[Test]
6536	····public void HasMappingTable()
6537	····{
6538	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6539	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6540	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6541	····}
6542	····[Test]
6543	····public void HasTypeColumn()
6544	····{
6545	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6546	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6547	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
6548	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6549	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
6550	····}
6551	····[Test]
6552	····public void HasTypeCode()
6553	····{
6554	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6555	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6556	····}
6557	}
6558
6559
6560	[TestFixture]
6561	public class MappingTestCmpDirnOwnpabsNoTblAuto : NDOTest
6562	{
6563	····PersistenceManager pm;
6564	····NDOMapping mapping;
6565	····Class ownClass;
6566	····Class otherClass;
6567	····Class ownDerivedClass;
6568	····[SetUp]
6569	····public void Setup()
6570	····{
6571	········this.pm = PmFactory.NewPersistenceManager();
6572	········this.mapping = pm.NDOMapping;
6573	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoLeftBase" );
6574	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoRight" );
6575	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblAutoLeftDerived" );
6576	····}
6577	····[Test]
6578	····public void HasMappingTable()
6579	····{
6580	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6581	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
6582	····}
6583	····[Test]
6584	····public void HasTypeColumn()
6585	····{
6586	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6587	····}
6588	····[Test]
6589	····public void HasTypeCode()
6590	····{
6591	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6592	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6593	····}
6594	}
6595
6596
6597	[TestFixture]
6598	public class MappingTestCmpDirnOwnpabsTblAuto : NDOTest
6599	{
6600	····PersistenceManager pm;
6601	····NDOMapping mapping;
6602	····Class ownClass;
6603	····Class otherClass;
6604	····Class ownDerivedClass;
6605	····[SetUp]
6606	····public void Setup()
6607	····{
6608	········this.pm = PmFactory.NewPersistenceManager();
6609	········this.mapping = pm.NDOMapping;
6610	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoLeftBase" );
6611	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoRight" );
6612	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblAutoLeftDerived" );
6613	····}
6614	····[Test]
6615	····public void HasMappingTable()
6616	····{
6617	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6618	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6619	····}
6620	····[Test]
6621	····public void HasTypeColumn()
6622	····{
6623	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6624	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6625	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6626	····}
6627	····[Test]
6628	····public void HasTypeCode()
6629	····{
6630	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6631	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6632	····}
6633	}
6634
6635
6636	[TestFixture]
6637	public class MappingTestCmpBin1OwnpabsNoTblAuto : NDOTest
6638	{
6639	····PersistenceManager pm;
6640	····NDOMapping mapping;
6641	····Class ownClass;
6642	····Class otherClass;
6643	····Class ownDerivedClass;
6644	····[SetUp]
6645	····public void Setup()
6646	····{
6647	········this.pm = PmFactory.NewPersistenceManager();
6648	········this.mapping = pm.NDOMapping;
6649	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoLeftBase" );
6650	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoRight" );
6651	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblAutoLeftDerived" );
6652	····}
6653	····[Test]
6654	····public void HasMappingTable()
6655	····{
6656	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6657	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
6658	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
6659	····}
6660	····[Test]
6661	····public void HasTypeColumn()
6662	····{
6663	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6664	····}
6665	····[Test]
6666	····public void HasTypeCode()
6667	····{
6668	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6669	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6670	····}
6671	}
6672
6673
6674	[TestFixture]
6675	public class MappingTestCmpBin1OwnpabsTblAuto : NDOTest
6676	{
6677	····PersistenceManager pm;
6678	····NDOMapping mapping;
6679	····Class ownClass;
6680	····Class otherClass;
6681	····Class ownDerivedClass;
6682	····[SetUp]
6683	····public void Setup()
6684	····{
6685	········this.pm = PmFactory.NewPersistenceManager();
6686	········this.mapping = pm.NDOMapping;
6687	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoLeftBase" );
6688	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoRight" );
6689	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblAutoLeftDerived" );
6690	····}
6691	····[Test]
6692	····public void HasMappingTable()
6693	····{
6694	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6695	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6696	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6697	····}
6698	····[Test]
6699	····public void HasTypeColumn()
6700	····{
6701	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6702	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6703	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
6704	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6705	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
6706	····}
6707	····[Test]
6708	····public void HasTypeCode()
6709	····{
6710	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6711	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6712	····}
6713	}
6714
6715
6716	[TestFixture]
6717	public class MappingTestCmpBi1nOwnpabsTblAuto : NDOTest
6718	{
6719	····PersistenceManager pm;
6720	····NDOMapping mapping;
6721	····Class ownClass;
6722	····Class otherClass;
6723	····Class ownDerivedClass;
6724	····[SetUp]
6725	····public void Setup()
6726	····{
6727	········this.pm = PmFactory.NewPersistenceManager();
6728	········this.mapping = pm.NDOMapping;
6729	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoLeftBase" );
6730	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoRight" );
6731	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblAutoLeftDerived" );
6732	····}
6733	····[Test]
6734	····public void HasMappingTable()
6735	····{
6736	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6737	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6738	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6739	····}
6740	····[Test]
6741	····public void HasTypeColumn()
6742	····{
6743	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6744	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6745	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
6746	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6747	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
6748	····}
6749	····[Test]
6750	····public void HasTypeCode()
6751	····{
6752	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6753	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6754	····}
6755	}
6756
6757
6758	[TestFixture]
6759	public class MappingTestCmpBinnOwnpabsTblAuto : NDOTest
6760	{
6761	····PersistenceManager pm;
6762	····NDOMapping mapping;
6763	····Class ownClass;
6764	····Class otherClass;
6765	····Class ownDerivedClass;
6766	····[SetUp]
6767	····public void Setup()
6768	····{
6769	········this.pm = PmFactory.NewPersistenceManager();
6770	········this.mapping = pm.NDOMapping;
6771	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoLeftBase" );
6772	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoRight" );
6773	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblAutoLeftDerived" );
6774	····}
6775	····[Test]
6776	····public void HasMappingTable()
6777	····{
6778	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6779	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
6780	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6781	····}
6782	····[Test]
6783	····public void HasTypeColumn()
6784	····{
6785	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
6786	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
6787	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
6788	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
6789	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
6790	····}
6791	····[Test]
6792	····public void HasTypeCode()
6793	····{
6794	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
6795	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
6796	····}
6797	}
6798
6799
6800	[TestFixture]
6801	public class MappingTestAgrDir1OthpabsNoTblAuto : NDOTest
6802	{
6803	····PersistenceManager pm;
6804	····NDOMapping mapping;
6805	····Class ownClass;
6806	····Class otherClass;
6807	····Class otherDerivedClass;
6808	····[SetUp]
6809	····public void Setup()
6810	····{
6811	········this.pm = PmFactory.NewPersistenceManager();
6812	········this.mapping = pm.NDOMapping;
6813	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoLeft" );
6814	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoRightBase" );
6815	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblAutoRightDerived" );
6816	····}
6817	····[Test]
6818	····public void HasMappingTable()
6819	····{
6820	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6821	····}
6822	····[Test]
6823	····public void HasTypeColumn()
6824	····{
6825	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
6826	····}
6827	····[Test]
6828	····public void HasTypeCode()
6829	····{
6830	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6831	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6832	····}
6833	}
6834
6835
6836	[TestFixture]
6837	public class MappingTestAgrDir1OthpabsTblAuto : NDOTest
6838	{
6839	····PersistenceManager pm;
6840	····NDOMapping mapping;
6841	····Class ownClass;
6842	····Class otherClass;
6843	····Class otherDerivedClass;
6844	····[SetUp]
6845	····public void Setup()
6846	····{
6847	········this.pm = PmFactory.NewPersistenceManager();
6848	········this.mapping = pm.NDOMapping;
6849	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoLeft" );
6850	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoRightBase" );
6851	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblAutoRightDerived" );
6852	····}
6853	····[Test]
6854	····public void HasMappingTable()
6855	····{
6856	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6857	····}
6858	····[Test]
6859	····public void HasTypeColumn()
6860	····{
6861	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
6862	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6863	····}
6864	····[Test]
6865	····public void HasTypeCode()
6866	····{
6867	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6868	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6869	····}
6870	}
6871
6872
6873	[TestFixture]
6874	public class MappingTestAgrBi11OthpabsNoTblAuto : NDOTest
6875	{
6876	····PersistenceManager pm;
6877	····NDOMapping mapping;
6878	····Class ownClass;
6879	····Class otherClass;
6880	····Class otherDerivedClass;
6881	····[SetUp]
6882	····public void Setup()
6883	····{
6884	········this.pm = PmFactory.NewPersistenceManager();
6885	········this.mapping = pm.NDOMapping;
6886	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoLeft" );
6887	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoRightBase" );
6888	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblAutoRightDerived" );
6889	····}
6890	····[Test]
6891	····public void HasMappingTable()
6892	····{
6893	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
6894	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
6895	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
6896	····}
6897	····[Test]
6898	····public void HasTypeColumn()
6899	····{
6900	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
6901	····}
6902	····[Test]
6903	····public void HasTypeCode()
6904	····{
6905	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6906	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6907	····}
6908	}
6909
6910
6911	[TestFixture]
6912	public class MappingTestAgrBi11OthpabsTblAuto : NDOTest
6913	{
6914	····PersistenceManager pm;
6915	····NDOMapping mapping;
6916	····Class ownClass;
6917	····Class otherClass;
6918	····Class otherDerivedClass;
6919	····[SetUp]
6920	····public void Setup()
6921	····{
6922	········this.pm = PmFactory.NewPersistenceManager();
6923	········this.mapping = pm.NDOMapping;
6924	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoLeft" );
6925	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoRightBase" );
6926	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblAutoRightDerived" );
6927	····}
6928	····[Test]
6929	····public void HasMappingTable()
6930	····{
6931	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6932	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
6933	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
6934	····}
6935	····[Test]
6936	····public void HasTypeColumn()
6937	····{
6938	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
6939	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
6940	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
6941	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6942	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
6943	····}
6944	····[Test]
6945	····public void HasTypeCode()
6946	····{
6947	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6948	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6949	····}
6950	}
6951
6952
6953	[TestFixture]
6954	public class MappingTestAgrDirnOthpabsTblAuto : NDOTest
6955	{
6956	····PersistenceManager pm;
6957	····NDOMapping mapping;
6958	····Class ownClass;
6959	····Class otherClass;
6960	····Class otherDerivedClass;
6961	····[SetUp]
6962	····public void Setup()
6963	····{
6964	········this.pm = PmFactory.NewPersistenceManager();
6965	········this.mapping = pm.NDOMapping;
6966	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoLeft" );
6967	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoRightBase" );
6968	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblAutoRightDerived" );
6969	····}
6970	····[Test]
6971	····public void HasMappingTable()
6972	····{
6973	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
6974	····}
6975	····[Test]
6976	····public void HasTypeColumn()
6977	····{
6978	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
6979	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
6980	····}
6981	····[Test]
6982	····public void HasTypeCode()
6983	····{
6984	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
6985	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
6986	····}
6987	}
6988
6989
6990	[TestFixture]
6991	public class MappingTestAgrBin1OthpabsTblAuto : NDOTest
6992	{
6993	····PersistenceManager pm;
6994	····NDOMapping mapping;
6995	····Class ownClass;
6996	····Class otherClass;
6997	····Class otherDerivedClass;
6998	····[SetUp]
6999	····public void Setup()
7000	····{
7001	········this.pm = PmFactory.NewPersistenceManager();
7002	········this.mapping = pm.NDOMapping;
7003	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoLeft" );
7004	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoRightBase" );
7005	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblAutoRightDerived" );
7006	····}
7007	····[Test]
7008	····public void HasMappingTable()
7009	····{
7010	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7011	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7012	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7013	····}
7014	····[Test]
7015	····public void HasTypeColumn()
7016	····{
7017	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7018	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7019	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7020	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7021	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
7022	····}
7023	····[Test]
7024	····public void HasTypeCode()
7025	····{
7026	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7027	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7028	····}
7029	}
7030
7031
7032	[TestFixture]
7033	public class MappingTestAgrBi1nOthpabsNoTblAuto : NDOTest
7034	{
7035	····PersistenceManager pm;
7036	····NDOMapping mapping;
7037	····Class ownClass;
7038	····Class otherClass;
7039	····Class otherDerivedClass;
7040	····[SetUp]
7041	····public void Setup()
7042	····{
7043	········this.pm = PmFactory.NewPersistenceManager();
7044	········this.mapping = pm.NDOMapping;
7045	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoLeft" );
7046	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoRightBase" );
7047	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblAutoRightDerived" );
7048	····}
7049	····[Test]
7050	····public void HasMappingTable()
7051	····{
7052	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
7053	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
7054	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
7055	····}
7056	····[Test]
7057	····public void HasTypeColumn()
7058	····{
7059	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
7060	····}
7061	····[Test]
7062	····public void HasTypeCode()
7063	····{
7064	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7065	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7066	····}
7067	}
7068
7069
7070	[TestFixture]
7071	public class MappingTestAgrBi1nOthpabsTblAuto : NDOTest
7072	{
7073	····PersistenceManager pm;
7074	····NDOMapping mapping;
7075	····Class ownClass;
7076	····Class otherClass;
7077	····Class otherDerivedClass;
7078	····[SetUp]
7079	····public void Setup()
7080	····{
7081	········this.pm = PmFactory.NewPersistenceManager();
7082	········this.mapping = pm.NDOMapping;
7083	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoLeft" );
7084	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoRightBase" );
7085	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblAutoRightDerived" );
7086	····}
7087	····[Test]
7088	····public void HasMappingTable()
7089	····{
7090	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7091	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7092	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7093	····}
7094	····[Test]
7095	····public void HasTypeColumn()
7096	····{
7097	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7098	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7099	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7100	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7101	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
7102	····}
7103	····[Test]
7104	····public void HasTypeCode()
7105	····{
7106	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7107	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7108	····}
7109	}
7110
7111
7112	[TestFixture]
7113	public class MappingTestAgrBinnOthpabsTblAuto : NDOTest
7114	{
7115	····PersistenceManager pm;
7116	····NDOMapping mapping;
7117	····Class ownClass;
7118	····Class otherClass;
7119	····Class otherDerivedClass;
7120	····[SetUp]
7121	····public void Setup()
7122	····{
7123	········this.pm = PmFactory.NewPersistenceManager();
7124	········this.mapping = pm.NDOMapping;
7125	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoLeft" );
7126	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoRightBase" );
7127	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblAutoRightDerived" );
7128	····}
7129	····[Test]
7130	····public void HasMappingTable()
7131	····{
7132	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7133	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7134	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7135	····}
7136	····[Test]
7137	····public void HasTypeColumn()
7138	····{
7139	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7140	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7141	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7142	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7143	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
7144	····}
7145	····[Test]
7146	····public void HasTypeCode()
7147	····{
7148	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7149	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7150	····}
7151	}
7152
7153
7154	[TestFixture]
7155	public class MappingTestCmpDir1OthpabsTblAuto : NDOTest
7156	{
7157	····PersistenceManager pm;
7158	····NDOMapping mapping;
7159	····Class ownClass;
7160	····Class otherClass;
7161	····Class otherDerivedClass;
7162	····[SetUp]
7163	····public void Setup()
7164	····{
7165	········this.pm = PmFactory.NewPersistenceManager();
7166	········this.mapping = pm.NDOMapping;
7167	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoLeft" );
7168	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoRightBase" );
7169	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblAutoRightDerived" );
7170	····}
7171	····[Test]
7172	····public void HasMappingTable()
7173	····{
7174	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7175	····}
7176	····[Test]
7177	····public void HasTypeColumn()
7178	····{
7179	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7180	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7181	····}
7182	····[Test]
7183	····public void HasTypeCode()
7184	····{
7185	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7186	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7187	····}
7188	}
7189
7190
7191	[TestFixture]
7192	public class MappingTestCmpBi11OthpabsTblAuto : NDOTest
7193	{
7194	····PersistenceManager pm;
7195	····NDOMapping mapping;
7196	····Class ownClass;
7197	····Class otherClass;
7198	····Class otherDerivedClass;
7199	····[SetUp]
7200	····public void Setup()
7201	····{
7202	········this.pm = PmFactory.NewPersistenceManager();
7203	········this.mapping = pm.NDOMapping;
7204	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoLeft" );
7205	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoRightBase" );
7206	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblAutoRightDerived" );
7207	····}
7208	····[Test]
7209	····public void HasMappingTable()
7210	····{
7211	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7212	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7213	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7214	····}
7215	····[Test]
7216	····public void HasTypeColumn()
7217	····{
7218	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7219	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7220	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7221	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7222	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
7223	····}
7224	····[Test]
7225	····public void HasTypeCode()
7226	····{
7227	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7228	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7229	····}
7230	}
7231
7232
7233	[TestFixture]
7234	public class MappingTestCmpDirnOthpabsTblAuto : NDOTest
7235	{
7236	····PersistenceManager pm;
7237	····NDOMapping mapping;
7238	····Class ownClass;
7239	····Class otherClass;
7240	····Class otherDerivedClass;
7241	····[SetUp]
7242	····public void Setup()
7243	····{
7244	········this.pm = PmFactory.NewPersistenceManager();
7245	········this.mapping = pm.NDOMapping;
7246	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoLeft" );
7247	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoRightBase" );
7248	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblAutoRightDerived" );
7249	····}
7250	····[Test]
7251	····public void HasMappingTable()
7252	····{
7253	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7254	····}
7255	····[Test]
7256	····public void HasTypeColumn()
7257	····{
7258	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7259	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7260	····}
7261	····[Test]
7262	····public void HasTypeCode()
7263	····{
7264	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7265	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7266	····}
7267	}
7268
7269
7270	[TestFixture]
7271	public class MappingTestCmpBin1OthpabsTblAuto : NDOTest
7272	{
7273	····PersistenceManager pm;
7274	····NDOMapping mapping;
7275	····Class ownClass;
7276	····Class otherClass;
7277	····Class otherDerivedClass;
7278	····[SetUp]
7279	····public void Setup()
7280	····{
7281	········this.pm = PmFactory.NewPersistenceManager();
7282	········this.mapping = pm.NDOMapping;
7283	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoLeft" );
7284	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoRightBase" );
7285	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblAutoRightDerived" );
7286	····}
7287	····[Test]
7288	····public void HasMappingTable()
7289	····{
7290	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7291	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7292	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7293	····}
7294	····[Test]
7295	····public void HasTypeColumn()
7296	····{
7297	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7298	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7299	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7300	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7301	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
7302	····}
7303	····[Test]
7304	····public void HasTypeCode()
7305	····{
7306	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7307	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7308	····}
7309	}
7310
7311
7312	[TestFixture]
7313	public class MappingTestCmpBi1nOthpabsTblAuto : NDOTest
7314	{
7315	····PersistenceManager pm;
7316	····NDOMapping mapping;
7317	····Class ownClass;
7318	····Class otherClass;
7319	····Class otherDerivedClass;
7320	····[SetUp]
7321	····public void Setup()
7322	····{
7323	········this.pm = PmFactory.NewPersistenceManager();
7324	········this.mapping = pm.NDOMapping;
7325	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoLeft" );
7326	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoRightBase" );
7327	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblAutoRightDerived" );
7328	····}
7329	····[Test]
7330	····public void HasMappingTable()
7331	····{
7332	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7333	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7334	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7335	····}
7336	····[Test]
7337	····public void HasTypeColumn()
7338	····{
7339	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7340	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7341	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7342	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7343	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
7344	····}
7345	····[Test]
7346	····public void HasTypeCode()
7347	····{
7348	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7349	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7350	····}
7351	}
7352
7353
7354	[TestFixture]
7355	public class MappingTestCmpBinnOthpabsTblAuto : NDOTest
7356	{
7357	····PersistenceManager pm;
7358	····NDOMapping mapping;
7359	····Class ownClass;
7360	····Class otherClass;
7361	····Class otherDerivedClass;
7362	····[SetUp]
7363	····public void Setup()
7364	····{
7365	········this.pm = PmFactory.NewPersistenceManager();
7366	········this.mapping = pm.NDOMapping;
7367	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoLeft" );
7368	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoRightBase" );
7369	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblAutoRightDerived" );
7370	····}
7371	····[Test]
7372	····public void HasMappingTable()
7373	····{
7374	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7375	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7376	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7377	····}
7378	····[Test]
7379	····public void HasTypeColumn()
7380	····{
7381	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7382	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7383	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7384	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
7385	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
7386	····}
7387	····[Test]
7388	····public void HasTypeCode()
7389	····{
7390	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
7391	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7392	····}
7393	}
7394
7395
7396	[TestFixture]
7397	public class MappingTestAgrDir1OwnpabsOthpabsNoTblAuto : NDOTest
7398	{
7399	····PersistenceManager pm;
7400	····NDOMapping mapping;
7401	····Class ownClass;
7402	····Class otherClass;
7403	····Class ownDerivedClass;
7404	····Class otherDerivedClass;
7405	····[SetUp]
7406	····public void Setup()
7407	····{
7408	········this.pm = PmFactory.NewPersistenceManager();
7409	········this.mapping = pm.NDOMapping;
7410	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoLeftBase" );
7411	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoRightBase" );
7412	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoLeftDerived" );
7413	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblAutoRightDerived" );
7414	····}
7415	····[Test]
7416	····public void HasMappingTable()
7417	····{
7418	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
7419	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
7420	····}
7421	····[Test]
7422	····public void HasTypeColumn()
7423	····{
7424	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
7425	····}
7426	····[Test]
7427	····public void HasTypeCode()
7428	····{
7429	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7430	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7431	····}
7432	}
7433
7434
7435	[TestFixture]
7436	public class MappingTestAgrDir1OwnpabsOthpabsTblAuto : NDOTest
7437	{
7438	····PersistenceManager pm;
7439	····NDOMapping mapping;
7440	····Class ownClass;
7441	····Class otherClass;
7442	····Class ownDerivedClass;
7443	····Class otherDerivedClass;
7444	····[SetUp]
7445	····public void Setup()
7446	····{
7447	········this.pm = PmFactory.NewPersistenceManager();
7448	········this.mapping = pm.NDOMapping;
7449	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoLeftBase" );
7450	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoRightBase" );
7451	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoLeftDerived" );
7452	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblAutoRightDerived" );
7453	····}
7454	····[Test]
7455	····public void HasMappingTable()
7456	····{
7457	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7458	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7459	····}
7460	····[Test]
7461	····public void HasTypeColumn()
7462	····{
7463	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7464	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7465	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7466	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7467	····}
7468	····[Test]
7469	····public void HasTypeCode()
7470	····{
7471	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7472	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7473	····}
7474	}
7475
7476
7477	[TestFixture]
7478	public class MappingTestAgrBi11OwnpabsOthpabsNoTblAuto : NDOTest
7479	{
7480	····PersistenceManager pm;
7481	····NDOMapping mapping;
7482	····Class ownClass;
7483	····Class otherClass;
7484	····Class ownDerivedClass;
7485	····Class otherDerivedClass;
7486	····[SetUp]
7487	····public void Setup()
7488	····{
7489	········this.pm = PmFactory.NewPersistenceManager();
7490	········this.mapping = pm.NDOMapping;
7491	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoLeftBase" );
7492	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoRightBase" );
7493	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoLeftDerived" );
7494	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblAutoRightDerived" );
7495	····}
7496	····[Test]
7497	····public void HasMappingTable()
7498	····{
7499	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
7500	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
7501	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
7502	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
7503	····}
7504	····[Test]
7505	····public void HasTypeColumn()
7506	····{
7507	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
7508	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
7509	····}
7510	····[Test]
7511	····public void HasTypeCode()
7512	····{
7513	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7514	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7515	····}
7516	}
7517
7518
7519	[TestFixture]
7520	public class MappingTestAgrBi11OwnpabsOthpabsTblAuto : NDOTest
7521	{
7522	····PersistenceManager pm;
7523	····NDOMapping mapping;
7524	····Class ownClass;
7525	····Class otherClass;
7526	····Class ownDerivedClass;
7527	····Class otherDerivedClass;
7528	····[SetUp]
7529	····public void Setup()
7530	····{
7531	········this.pm = PmFactory.NewPersistenceManager();
7532	········this.mapping = pm.NDOMapping;
7533	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoLeftBase" );
7534	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoRightBase" );
7535	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoLeftDerived" );
7536	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblAutoRightDerived" );
7537	····}
7538	····[Test]
7539	····public void HasMappingTable()
7540	····{
7541	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7542	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7543	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7544	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7545	····}
7546	····[Test]
7547	····public void HasTypeColumn()
7548	····{
7549	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7550	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7551	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7552	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7553	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7554	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7555	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
7556	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
7557	····}
7558	····[Test]
7559	····public void HasTypeCode()
7560	····{
7561	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7562	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7563	····}
7564	}
7565
7566
7567	[TestFixture]
7568	public class MappingTestAgrDirnOwnpabsOthpabsTblAuto : NDOTest
7569	{
7570	····PersistenceManager pm;
7571	····NDOMapping mapping;
7572	····Class ownClass;
7573	····Class otherClass;
7574	····Class ownDerivedClass;
7575	····Class otherDerivedClass;
7576	····[SetUp]
7577	····public void Setup()
7578	····{
7579	········this.pm = PmFactory.NewPersistenceManager();
7580	········this.mapping = pm.NDOMapping;
7581	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoLeftBase" );
7582	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoRightBase" );
7583	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoLeftDerived" );
7584	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblAutoRightDerived" );
7585	····}
7586	····[Test]
7587	····public void HasMappingTable()
7588	····{
7589	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7590	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7591	····}
7592	····[Test]
7593	····public void HasTypeColumn()
7594	····{
7595	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7596	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7597	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7598	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7599	····}
7600	····[Test]
7601	····public void HasTypeCode()
7602	····{
7603	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7604	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7605	····}
7606	}
7607
7608
7609	[TestFixture]
7610	public class MappingTestAgrBin1OwnpabsOthpabsTblAuto : NDOTest
7611	{
7612	····PersistenceManager pm;
7613	····NDOMapping mapping;
7614	····Class ownClass;
7615	····Class otherClass;
7616	····Class ownDerivedClass;
7617	····Class otherDerivedClass;
7618	····[SetUp]
7619	····public void Setup()
7620	····{
7621	········this.pm = PmFactory.NewPersistenceManager();
7622	········this.mapping = pm.NDOMapping;
7623	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoLeftBase" );
7624	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoRightBase" );
7625	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoLeftDerived" );
7626	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblAutoRightDerived" );
7627	····}
7628	····[Test]
7629	····public void HasMappingTable()
7630	····{
7631	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7632	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7633	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7634	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7635	····}
7636	····[Test]
7637	····public void HasTypeColumn()
7638	····{
7639	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7640	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7641	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7642	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7643	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7644	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7645	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
7646	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
7647	····}
7648	····[Test]
7649	····public void HasTypeCode()
7650	····{
7651	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7652	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7653	····}
7654	}
7655
7656
7657	[TestFixture]
7658	public class MappingTestAgrBi1nOwnpabsOthpabsTblAuto : NDOTest
7659	{
7660	····PersistenceManager pm;
7661	····NDOMapping mapping;
7662	····Class ownClass;
7663	····Class otherClass;
7664	····Class ownDerivedClass;
7665	····Class otherDerivedClass;
7666	····[SetUp]
7667	····public void Setup()
7668	····{
7669	········this.pm = PmFactory.NewPersistenceManager();
7670	········this.mapping = pm.NDOMapping;
7671	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoLeftBase" );
7672	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoRightBase" );
7673	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoLeftDerived" );
7674	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblAutoRightDerived" );
7675	····}
7676	····[Test]
7677	····public void HasMappingTable()
7678	····{
7679	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7680	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7681	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7682	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7683	····}
7684	····[Test]
7685	····public void HasTypeColumn()
7686	····{
7687	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7688	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7689	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7690	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7691	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7692	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7693	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
7694	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
7695	····}
7696	····[Test]
7697	····public void HasTypeCode()
7698	····{
7699	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7700	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7701	····}
7702	}
7703
7704
7705	[TestFixture]
7706	public class MappingTestAgrBinnOwnpabsOthpabsTblAuto : NDOTest
7707	{
7708	····PersistenceManager pm;
7709	····NDOMapping mapping;
7710	····Class ownClass;
7711	····Class otherClass;
7712	····Class ownDerivedClass;
7713	····Class otherDerivedClass;
7714	····[SetUp]
7715	····public void Setup()
7716	····{
7717	········this.pm = PmFactory.NewPersistenceManager();
7718	········this.mapping = pm.NDOMapping;
7719	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoLeftBase" );
7720	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoRightBase" );
7721	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoLeftDerived" );
7722	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblAutoRightDerived" );
7723	····}
7724	····[Test]
7725	····public void HasMappingTable()
7726	····{
7727	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7728	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7729	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7730	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7731	····}
7732	····[Test]
7733	····public void HasTypeColumn()
7734	····{
7735	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7736	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7737	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7738	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7739	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7740	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7741	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
7742	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
7743	····}
7744	····[Test]
7745	····public void HasTypeCode()
7746	····{
7747	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7748	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7749	····}
7750	}
7751
7752
7753	[TestFixture]
7754	public class MappingTestCmpDir1OwnpabsOthpabsTblAuto : NDOTest
7755	{
7756	····PersistenceManager pm;
7757	····NDOMapping mapping;
7758	····Class ownClass;
7759	····Class otherClass;
7760	····Class ownDerivedClass;
7761	····Class otherDerivedClass;
7762	····[SetUp]
7763	····public void Setup()
7764	····{
7765	········this.pm = PmFactory.NewPersistenceManager();
7766	········this.mapping = pm.NDOMapping;
7767	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoLeftBase" );
7768	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoRightBase" );
7769	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoLeftDerived" );
7770	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblAutoRightDerived" );
7771	····}
7772	····[Test]
7773	····public void HasMappingTable()
7774	····{
7775	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7776	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7777	····}
7778	····[Test]
7779	····public void HasTypeColumn()
7780	····{
7781	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7782	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7783	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7784	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7785	····}
7786	····[Test]
7787	····public void HasTypeCode()
7788	····{
7789	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7790	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7791	····}
7792	}
7793
7794
7795	[TestFixture]
7796	public class MappingTestCmpBi11OwnpabsOthpabsTblAuto : NDOTest
7797	{
7798	····PersistenceManager pm;
7799	····NDOMapping mapping;
7800	····Class ownClass;
7801	····Class otherClass;
7802	····Class ownDerivedClass;
7803	····Class otherDerivedClass;
7804	····[SetUp]
7805	····public void Setup()
7806	····{
7807	········this.pm = PmFactory.NewPersistenceManager();
7808	········this.mapping = pm.NDOMapping;
7809	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoLeftBase" );
7810	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoRightBase" );
7811	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoLeftDerived" );
7812	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblAutoRightDerived" );
7813	····}
7814	····[Test]
7815	····public void HasMappingTable()
7816	····{
7817	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7818	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7819	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7820	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7821	····}
7822	····[Test]
7823	····public void HasTypeColumn()
7824	····{
7825	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7826	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7827	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7828	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7829	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7830	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7831	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
7832	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
7833	····}
7834	····[Test]
7835	····public void HasTypeCode()
7836	····{
7837	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7838	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7839	····}
7840	}
7841
7842
7843	[TestFixture]
7844	public class MappingTestCmpDirnOwnpabsOthpabsTblAuto : NDOTest
7845	{
7846	····PersistenceManager pm;
7847	····NDOMapping mapping;
7848	····Class ownClass;
7849	····Class otherClass;
7850	····Class ownDerivedClass;
7851	····Class otherDerivedClass;
7852	····[SetUp]
7853	····public void Setup()
7854	····{
7855	········this.pm = PmFactory.NewPersistenceManager();
7856	········this.mapping = pm.NDOMapping;
7857	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoLeftBase" );
7858	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoRightBase" );
7859	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoLeftDerived" );
7860	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblAutoRightDerived" );
7861	····}
7862	····[Test]
7863	····public void HasMappingTable()
7864	····{
7865	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7866	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7867	····}
7868	····[Test]
7869	····public void HasTypeColumn()
7870	····{
7871	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7872	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7873	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7874	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7875	····}
7876	····[Test]
7877	····public void HasTypeCode()
7878	····{
7879	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7880	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7881	····}
7882	}
7883
7884
7885	[TestFixture]
7886	public class MappingTestCmpBin1OwnpabsOthpabsTblAuto : NDOTest
7887	{
7888	····PersistenceManager pm;
7889	····NDOMapping mapping;
7890	····Class ownClass;
7891	····Class otherClass;
7892	····Class ownDerivedClass;
7893	····Class otherDerivedClass;
7894	····[SetUp]
7895	····public void Setup()
7896	····{
7897	········this.pm = PmFactory.NewPersistenceManager();
7898	········this.mapping = pm.NDOMapping;
7899	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoLeftBase" );
7900	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoRightBase" );
7901	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoLeftDerived" );
7902	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblAutoRightDerived" );
7903	····}
7904	····[Test]
7905	····public void HasMappingTable()
7906	····{
7907	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7908	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7909	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7910	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7911	····}
7912	····[Test]
7913	····public void HasTypeColumn()
7914	····{
7915	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7916	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7917	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7918	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7919	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7920	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7921	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
7922	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
7923	····}
7924	····[Test]
7925	····public void HasTypeCode()
7926	····{
7927	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7928	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7929	····}
7930	}
7931
7932
7933	[TestFixture]
7934	public class MappingTestCmpBi1nOwnpabsOthpabsTblAuto : NDOTest
7935	{
7936	····PersistenceManager pm;
7937	····NDOMapping mapping;
7938	····Class ownClass;
7939	····Class otherClass;
7940	····Class ownDerivedClass;
7941	····Class otherDerivedClass;
7942	····[SetUp]
7943	····public void Setup()
7944	····{
7945	········this.pm = PmFactory.NewPersistenceManager();
7946	········this.mapping = pm.NDOMapping;
7947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoLeftBase" );
7948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoRightBase" );
7949	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoLeftDerived" );
7950	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblAutoRightDerived" );
7951	····}
7952	····[Test]
7953	····public void HasMappingTable()
7954	····{
7955	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
7956	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
7957	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
7958	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
7959	····}
7960	····[Test]
7961	····public void HasTypeColumn()
7962	····{
7963	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
7964	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
7965	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
7966	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
7967	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
7968	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
7969	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
7970	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
7971	····}
7972	····[Test]
7973	····public void HasTypeCode()
7974	····{
7975	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
7976	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
7977	····}
7978	}
7979
7980
7981	[TestFixture]
7982	public class MappingTestCmpBinnOwnpabsOthpabsTblAuto : NDOTest
7983	{
7984	····PersistenceManager pm;
7985	····NDOMapping mapping;
7986	····Class ownClass;
7987	····Class otherClass;
7988	····Class ownDerivedClass;
7989	····Class otherDerivedClass;
7990	····[SetUp]
7991	····public void Setup()
7992	····{
7993	········this.pm = PmFactory.NewPersistenceManager();
7994	········this.mapping = pm.NDOMapping;
7995	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoLeftBase" );
7996	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoRightBase" );
7997	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoLeftDerived" );
7998	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblAutoRightDerived" );
7999	····}
8000	····[Test]
8001	····public void HasMappingTable()
8002	····{
8003	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8004	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8005	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8006	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
8007	····}
8008	····[Test]
8009	····public void HasTypeColumn()
8010	····{
8011	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8012	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8013	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
8014	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
8015	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
8016	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
8017	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8018	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
8019	····}
8020	····[Test]
8021	····public void HasTypeCode()
8022	····{
8023	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8024	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8025	····}
8026	}
8027
8028
8029	[TestFixture]
8030	public class MappingTestAgrDir1OwnpabsNoTblGuid : NDOTest
8031	{
8032	····PersistenceManager pm;
8033	····NDOMapping mapping;
8034	····Class ownClass;
8035	····Class otherClass;
8036	····Class ownDerivedClass;
8037	····[SetUp]
8038	····public void Setup()
8039	····{
8040	········this.pm = PmFactory.NewPersistenceManager();
8041	········this.mapping = pm.NDOMapping;
8042	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidLeftBase" );
8043	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidRight" );
8044	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsNoTblGuidLeftDerived" );
8045	····}
8046	····[Test]
8047	····public void HasMappingTable()
8048	····{
8049	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8050	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
8051	····}
8052	····[Test]
8053	····public void HasTypeColumn()
8054	····{
8055	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8056	····}
8057	····[Test]
8058	····public void HasTypeCode()
8059	····{
8060	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8061	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8062	····}
8063	}
8064
8065
8066	[TestFixture]
8067	public class MappingTestAgrDir1OwnpabsTblGuid : NDOTest
8068	{
8069	····PersistenceManager pm;
8070	····NDOMapping mapping;
8071	····Class ownClass;
8072	····Class otherClass;
8073	····Class ownDerivedClass;
8074	····[SetUp]
8075	····public void Setup()
8076	····{
8077	········this.pm = PmFactory.NewPersistenceManager();
8078	········this.mapping = pm.NDOMapping;
8079	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidLeftBase" );
8080	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidRight" );
8081	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsTblGuidLeftDerived" );
8082	····}
8083	····[Test]
8084	····public void HasMappingTable()
8085	····{
8086	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8087	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8088	····}
8089	····[Test]
8090	····public void HasTypeColumn()
8091	····{
8092	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8093	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8094	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8095	····}
8096	····[Test]
8097	····public void HasTypeCode()
8098	····{
8099	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8100	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8101	····}
8102	}
8103
8104
8105	[TestFixture]
8106	public class MappingTestAgrBi11OwnpabsNoTblGuid : NDOTest
8107	{
8108	····PersistenceManager pm;
8109	····NDOMapping mapping;
8110	····Class ownClass;
8111	····Class otherClass;
8112	····Class ownDerivedClass;
8113	····[SetUp]
8114	····public void Setup()
8115	····{
8116	········this.pm = PmFactory.NewPersistenceManager();
8117	········this.mapping = pm.NDOMapping;
8118	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidLeftBase" );
8119	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidRight" );
8120	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsNoTblGuidLeftDerived" );
8121	····}
8122	····[Test]
8123	····public void HasMappingTable()
8124	····{
8125	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8126	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
8127	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
8128	····}
8129	····[Test]
8130	····public void HasTypeColumn()
8131	····{
8132	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8133	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
8134	····}
8135	····[Test]
8136	····public void HasTypeCode()
8137	····{
8138	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8139	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8140	····}
8141	}
8142
8143
8144	[TestFixture]
8145	public class MappingTestAgrBi11OwnpabsTblGuid : NDOTest
8146	{
8147	····PersistenceManager pm;
8148	····NDOMapping mapping;
8149	····Class ownClass;
8150	····Class otherClass;
8151	····Class ownDerivedClass;
8152	····[SetUp]
8153	····public void Setup()
8154	····{
8155	········this.pm = PmFactory.NewPersistenceManager();
8156	········this.mapping = pm.NDOMapping;
8157	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidLeftBase" );
8158	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidRight" );
8159	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsTblGuidLeftDerived" );
8160	····}
8161	····[Test]
8162	····public void HasMappingTable()
8163	····{
8164	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8165	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8166	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8167	····}
8168	····[Test]
8169	····public void HasTypeColumn()
8170	····{
8171	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8172	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8173	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8174	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8175	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
8176	····}
8177	····[Test]
8178	····public void HasTypeCode()
8179	····{
8180	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8181	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8182	····}
8183	}
8184
8185
8186	[TestFixture]
8187	public class MappingTestAgrDirnOwnpabsNoTblGuid : NDOTest
8188	{
8189	····PersistenceManager pm;
8190	····NDOMapping mapping;
8191	····Class ownClass;
8192	····Class otherClass;
8193	····Class ownDerivedClass;
8194	····[SetUp]
8195	····public void Setup()
8196	····{
8197	········this.pm = PmFactory.NewPersistenceManager();
8198	········this.mapping = pm.NDOMapping;
8199	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidLeftBase" );
8200	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidRight" );
8201	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsNoTblGuidLeftDerived" );
8202	····}
8203	····[Test]
8204	····public void HasMappingTable()
8205	····{
8206	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8207	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
8208	····}
8209	····[Test]
8210	····public void HasTypeColumn()
8211	····{
8212	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8213	····}
8214	····[Test]
8215	····public void HasTypeCode()
8216	····{
8217	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8218	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8219	····}
8220	}
8221
8222
8223	[TestFixture]
8224	public class MappingTestAgrDirnOwnpabsTblGuid : NDOTest
8225	{
8226	····PersistenceManager pm;
8227	····NDOMapping mapping;
8228	····Class ownClass;
8229	····Class otherClass;
8230	····Class ownDerivedClass;
8231	····[SetUp]
8232	····public void Setup()
8233	····{
8234	········this.pm = PmFactory.NewPersistenceManager();
8235	········this.mapping = pm.NDOMapping;
8236	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidLeftBase" );
8237	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidRight" );
8238	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsTblGuidLeftDerived" );
8239	····}
8240	····[Test]
8241	····public void HasMappingTable()
8242	····{
8243	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8244	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8245	····}
8246	····[Test]
8247	····public void HasTypeColumn()
8248	····{
8249	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8250	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8251	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8252	····}
8253	····[Test]
8254	····public void HasTypeCode()
8255	····{
8256	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8257	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8258	····}
8259	}
8260
8261
8262	[TestFixture]
8263	public class MappingTestAgrBin1OwnpabsNoTblGuid : NDOTest
8264	{
8265	····PersistenceManager pm;
8266	····NDOMapping mapping;
8267	····Class ownClass;
8268	····Class otherClass;
8269	····Class ownDerivedClass;
8270	····[SetUp]
8271	····public void Setup()
8272	····{
8273	········this.pm = PmFactory.NewPersistenceManager();
8274	········this.mapping = pm.NDOMapping;
8275	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidLeftBase" );
8276	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidRight" );
8277	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsNoTblGuidLeftDerived" );
8278	····}
8279	····[Test]
8280	····public void HasMappingTable()
8281	····{
8282	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8283	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
8284	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
8285	····}
8286	····[Test]
8287	····public void HasTypeColumn()
8288	····{
8289	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8290	····}
8291	····[Test]
8292	····public void HasTypeCode()
8293	····{
8294	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8295	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8296	····}
8297	}
8298
8299
8300	[TestFixture]
8301	public class MappingTestAgrBin1OwnpabsTblGuid : NDOTest
8302	{
8303	····PersistenceManager pm;
8304	····NDOMapping mapping;
8305	····Class ownClass;
8306	····Class otherClass;
8307	····Class ownDerivedClass;
8308	····[SetUp]
8309	····public void Setup()
8310	····{
8311	········this.pm = PmFactory.NewPersistenceManager();
8312	········this.mapping = pm.NDOMapping;
8313	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidLeftBase" );
8314	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidRight" );
8315	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsTblGuidLeftDerived" );
8316	····}
8317	····[Test]
8318	····public void HasMappingTable()
8319	····{
8320	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8321	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8322	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8323	····}
8324	····[Test]
8325	····public void HasTypeColumn()
8326	····{
8327	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8328	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8329	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8330	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8331	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
8332	····}
8333	····[Test]
8334	····public void HasTypeCode()
8335	····{
8336	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8337	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8338	····}
8339	}
8340
8341
8342	[TestFixture]
8343	public class MappingTestAgrBi1nOwnpabsTblGuid : NDOTest
8344	{
8345	····PersistenceManager pm;
8346	····NDOMapping mapping;
8347	····Class ownClass;
8348	····Class otherClass;
8349	····Class ownDerivedClass;
8350	····[SetUp]
8351	····public void Setup()
8352	····{
8353	········this.pm = PmFactory.NewPersistenceManager();
8354	········this.mapping = pm.NDOMapping;
8355	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidLeftBase" );
8356	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidRight" );
8357	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsTblGuidLeftDerived" );
8358	····}
8359	····[Test]
8360	····public void HasMappingTable()
8361	····{
8362	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8363	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8364	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8365	····}
8366	····[Test]
8367	····public void HasTypeColumn()
8368	····{
8369	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8370	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8371	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8372	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8373	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
8374	····}
8375	····[Test]
8376	····public void HasTypeCode()
8377	····{
8378	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8379	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8380	····}
8381	}
8382
8383
8384	[TestFixture]
8385	public class MappingTestAgrBinnOwnpabsTblGuid : NDOTest
8386	{
8387	····PersistenceManager pm;
8388	····NDOMapping mapping;
8389	····Class ownClass;
8390	····Class otherClass;
8391	····Class ownDerivedClass;
8392	····[SetUp]
8393	····public void Setup()
8394	····{
8395	········this.pm = PmFactory.NewPersistenceManager();
8396	········this.mapping = pm.NDOMapping;
8397	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidLeftBase" );
8398	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidRight" );
8399	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsTblGuidLeftDerived" );
8400	····}
8401	····[Test]
8402	····public void HasMappingTable()
8403	····{
8404	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8405	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8406	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8407	····}
8408	····[Test]
8409	····public void HasTypeColumn()
8410	····{
8411	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8412	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8413	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8414	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8415	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
8416	····}
8417	····[Test]
8418	····public void HasTypeCode()
8419	····{
8420	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8421	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8422	····}
8423	}
8424
8425
8426	[TestFixture]
8427	public class MappingTestCmpDir1OwnpabsNoTblGuid : NDOTest
8428	{
8429	····PersistenceManager pm;
8430	····NDOMapping mapping;
8431	····Class ownClass;
8432	····Class otherClass;
8433	····Class ownDerivedClass;
8434	····[SetUp]
8435	····public void Setup()
8436	····{
8437	········this.pm = PmFactory.NewPersistenceManager();
8438	········this.mapping = pm.NDOMapping;
8439	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidLeftBase" );
8440	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidRight" );
8441	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsNoTblGuidLeftDerived" );
8442	····}
8443	····[Test]
8444	····public void HasMappingTable()
8445	····{
8446	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8447	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
8448	····}
8449	····[Test]
8450	····public void HasTypeColumn()
8451	····{
8452	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8453	····}
8454	····[Test]
8455	····public void HasTypeCode()
8456	····{
8457	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8458	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8459	····}
8460	}
8461
8462
8463	[TestFixture]
8464	public class MappingTestCmpDir1OwnpabsTblGuid : NDOTest
8465	{
8466	····PersistenceManager pm;
8467	····NDOMapping mapping;
8468	····Class ownClass;
8469	····Class otherClass;
8470	····Class ownDerivedClass;
8471	····[SetUp]
8472	····public void Setup()
8473	····{
8474	········this.pm = PmFactory.NewPersistenceManager();
8475	········this.mapping = pm.NDOMapping;
8476	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidLeftBase" );
8477	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidRight" );
8478	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsTblGuidLeftDerived" );
8479	····}
8480	····[Test]
8481	····public void HasMappingTable()
8482	····{
8483	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8484	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8485	····}
8486	····[Test]
8487	····public void HasTypeColumn()
8488	····{
8489	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8490	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8491	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8492	····}
8493	····[Test]
8494	····public void HasTypeCode()
8495	····{
8496	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8497	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8498	····}
8499	}
8500
8501
8502	[TestFixture]
8503	public class MappingTestCmpBi11OwnpabsNoTblGuid : NDOTest
8504	{
8505	····PersistenceManager pm;
8506	····NDOMapping mapping;
8507	····Class ownClass;
8508	····Class otherClass;
8509	····Class ownDerivedClass;
8510	····[SetUp]
8511	····public void Setup()
8512	····{
8513	········this.pm = PmFactory.NewPersistenceManager();
8514	········this.mapping = pm.NDOMapping;
8515	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidLeftBase" );
8516	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidRight" );
8517	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsNoTblGuidLeftDerived" );
8518	····}
8519	····[Test]
8520	····public void HasMappingTable()
8521	····{
8522	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8523	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
8524	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
8525	····}
8526	····[Test]
8527	····public void HasTypeColumn()
8528	····{
8529	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8530	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
8531	····}
8532	····[Test]
8533	····public void HasTypeCode()
8534	····{
8535	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8536	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8537	····}
8538	}
8539
8540
8541	[TestFixture]
8542	public class MappingTestCmpBi11OwnpabsTblGuid : NDOTest
8543	{
8544	····PersistenceManager pm;
8545	····NDOMapping mapping;
8546	····Class ownClass;
8547	····Class otherClass;
8548	····Class ownDerivedClass;
8549	····[SetUp]
8550	····public void Setup()
8551	····{
8552	········this.pm = PmFactory.NewPersistenceManager();
8553	········this.mapping = pm.NDOMapping;
8554	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidLeftBase" );
8555	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidRight" );
8556	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsTblGuidLeftDerived" );
8557	····}
8558	····[Test]
8559	····public void HasMappingTable()
8560	····{
8561	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8562	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8563	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8564	····}
8565	····[Test]
8566	····public void HasTypeColumn()
8567	····{
8568	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8569	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8570	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8571	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8572	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
8573	····}
8574	····[Test]
8575	····public void HasTypeCode()
8576	····{
8577	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8578	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8579	····}
8580	}
8581
8582
8583	[TestFixture]
8584	public class MappingTestCmpDirnOwnpabsNoTblGuid : NDOTest
8585	{
8586	····PersistenceManager pm;
8587	····NDOMapping mapping;
8588	····Class ownClass;
8589	····Class otherClass;
8590	····Class ownDerivedClass;
8591	····[SetUp]
8592	····public void Setup()
8593	····{
8594	········this.pm = PmFactory.NewPersistenceManager();
8595	········this.mapping = pm.NDOMapping;
8596	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidLeftBase" );
8597	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidRight" );
8598	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsNoTblGuidLeftDerived" );
8599	····}
8600	····[Test]
8601	····public void HasMappingTable()
8602	····{
8603	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8604	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
8605	····}
8606	····[Test]
8607	····public void HasTypeColumn()
8608	····{
8609	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8610	····}
8611	····[Test]
8612	····public void HasTypeCode()
8613	····{
8614	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8615	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8616	····}
8617	}
8618
8619
8620	[TestFixture]
8621	public class MappingTestCmpDirnOwnpabsTblGuid : NDOTest
8622	{
8623	····PersistenceManager pm;
8624	····NDOMapping mapping;
8625	····Class ownClass;
8626	····Class otherClass;
8627	····Class ownDerivedClass;
8628	····[SetUp]
8629	····public void Setup()
8630	····{
8631	········this.pm = PmFactory.NewPersistenceManager();
8632	········this.mapping = pm.NDOMapping;
8633	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidLeftBase" );
8634	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidRight" );
8635	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsTblGuidLeftDerived" );
8636	····}
8637	····[Test]
8638	····public void HasMappingTable()
8639	····{
8640	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8641	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8642	····}
8643	····[Test]
8644	····public void HasTypeColumn()
8645	····{
8646	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8647	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8648	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8649	····}
8650	····[Test]
8651	····public void HasTypeCode()
8652	····{
8653	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8654	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8655	····}
8656	}
8657
8658
8659	[TestFixture]
8660	public class MappingTestCmpBin1OwnpabsNoTblGuid : NDOTest
8661	{
8662	····PersistenceManager pm;
8663	····NDOMapping mapping;
8664	····Class ownClass;
8665	····Class otherClass;
8666	····Class ownDerivedClass;
8667	····[SetUp]
8668	····public void Setup()
8669	····{
8670	········this.pm = PmFactory.NewPersistenceManager();
8671	········this.mapping = pm.NDOMapping;
8672	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidLeftBase" );
8673	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidRight" );
8674	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsNoTblGuidLeftDerived" );
8675	····}
8676	····[Test]
8677	····public void HasMappingTable()
8678	····{
8679	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8680	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
8681	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
8682	····}
8683	····[Test]
8684	····public void HasTypeColumn()
8685	····{
8686	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8687	····}
8688	····[Test]
8689	····public void HasTypeCode()
8690	····{
8691	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8692	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8693	····}
8694	}
8695
8696
8697	[TestFixture]
8698	public class MappingTestCmpBin1OwnpabsTblGuid : NDOTest
8699	{
8700	····PersistenceManager pm;
8701	····NDOMapping mapping;
8702	····Class ownClass;
8703	····Class otherClass;
8704	····Class ownDerivedClass;
8705	····[SetUp]
8706	····public void Setup()
8707	····{
8708	········this.pm = PmFactory.NewPersistenceManager();
8709	········this.mapping = pm.NDOMapping;
8710	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidLeftBase" );
8711	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidRight" );
8712	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsTblGuidLeftDerived" );
8713	····}
8714	····[Test]
8715	····public void HasMappingTable()
8716	····{
8717	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8718	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8719	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8720	····}
8721	····[Test]
8722	····public void HasTypeColumn()
8723	····{
8724	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8725	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8726	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8727	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8728	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
8729	····}
8730	····[Test]
8731	····public void HasTypeCode()
8732	····{
8733	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8734	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8735	····}
8736	}
8737
8738
8739	[TestFixture]
8740	public class MappingTestCmpBi1nOwnpabsTblGuid : NDOTest
8741	{
8742	····PersistenceManager pm;
8743	····NDOMapping mapping;
8744	····Class ownClass;
8745	····Class otherClass;
8746	····Class ownDerivedClass;
8747	····[SetUp]
8748	····public void Setup()
8749	····{
8750	········this.pm = PmFactory.NewPersistenceManager();
8751	········this.mapping = pm.NDOMapping;
8752	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidLeftBase" );
8753	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidRight" );
8754	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsTblGuidLeftDerived" );
8755	····}
8756	····[Test]
8757	····public void HasMappingTable()
8758	····{
8759	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8760	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8761	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8762	····}
8763	····[Test]
8764	····public void HasTypeColumn()
8765	····{
8766	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8767	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8768	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8769	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8770	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
8771	····}
8772	····[Test]
8773	····public void HasTypeCode()
8774	····{
8775	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8776	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8777	····}
8778	}
8779
8780
8781	[TestFixture]
8782	public class MappingTestCmpBinnOwnpabsTblGuid : NDOTest
8783	{
8784	····PersistenceManager pm;
8785	····NDOMapping mapping;
8786	····Class ownClass;
8787	····Class otherClass;
8788	····Class ownDerivedClass;
8789	····[SetUp]
8790	····public void Setup()
8791	····{
8792	········this.pm = PmFactory.NewPersistenceManager();
8793	········this.mapping = pm.NDOMapping;
8794	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidLeftBase" );
8795	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidRight" );
8796	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsTblGuidLeftDerived" );
8797	····}
8798	····[Test]
8799	····public void HasMappingTable()
8800	····{
8801	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8802	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
8803	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8804	····}
8805	····[Test]
8806	····public void HasTypeColumn()
8807	····{
8808	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
8809	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
8810	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
8811	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #3") ;
8812	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #4") ;
8813	····}
8814	····[Test]
8815	····public void HasTypeCode()
8816	····{
8817	········Assert.That(this.otherClass.TypeCode != 0, "Class should have a Type Code #2");
8818	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
8819	····}
8820	}
8821
8822
8823	[TestFixture]
8824	public class MappingTestAgrDir1OthpabsNoTblGuid : NDOTest
8825	{
8826	····PersistenceManager pm;
8827	····NDOMapping mapping;
8828	····Class ownClass;
8829	····Class otherClass;
8830	····Class otherDerivedClass;
8831	····[SetUp]
8832	····public void Setup()
8833	····{
8834	········this.pm = PmFactory.NewPersistenceManager();
8835	········this.mapping = pm.NDOMapping;
8836	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidLeft" );
8837	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidRightBase" );
8838	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsNoTblGuidRightDerived" );
8839	····}
8840	····[Test]
8841	····public void HasMappingTable()
8842	····{
8843	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8844	····}
8845	····[Test]
8846	····public void HasTypeColumn()
8847	····{
8848	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
8849	····}
8850	····[Test]
8851	····public void HasTypeCode()
8852	····{
8853	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8854	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8855	····}
8856	}
8857
8858
8859	[TestFixture]
8860	public class MappingTestAgrDir1OthpabsTblGuid : NDOTest
8861	{
8862	····PersistenceManager pm;
8863	····NDOMapping mapping;
8864	····Class ownClass;
8865	····Class otherClass;
8866	····Class otherDerivedClass;
8867	····[SetUp]
8868	····public void Setup()
8869	····{
8870	········this.pm = PmFactory.NewPersistenceManager();
8871	········this.mapping = pm.NDOMapping;
8872	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidLeft" );
8873	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidRightBase" );
8874	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OthpabsTblGuidRightDerived" );
8875	····}
8876	····[Test]
8877	····public void HasMappingTable()
8878	····{
8879	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8880	····}
8881	····[Test]
8882	····public void HasTypeColumn()
8883	····{
8884	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
8885	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8886	····}
8887	····[Test]
8888	····public void HasTypeCode()
8889	····{
8890	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8891	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8892	····}
8893	}
8894
8895
8896	[TestFixture]
8897	public class MappingTestAgrBi11OthpabsNoTblGuid : NDOTest
8898	{
8899	····PersistenceManager pm;
8900	····NDOMapping mapping;
8901	····Class ownClass;
8902	····Class otherClass;
8903	····Class otherDerivedClass;
8904	····[SetUp]
8905	····public void Setup()
8906	····{
8907	········this.pm = PmFactory.NewPersistenceManager();
8908	········this.mapping = pm.NDOMapping;
8909	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidLeft" );
8910	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidRightBase" );
8911	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsNoTblGuidRightDerived" );
8912	····}
8913	····[Test]
8914	····public void HasMappingTable()
8915	····{
8916	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
8917	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
8918	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
8919	····}
8920	····[Test]
8921	····public void HasTypeColumn()
8922	····{
8923	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
8924	····}
8925	····[Test]
8926	····public void HasTypeCode()
8927	····{
8928	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8929	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8930	····}
8931	}
8932
8933
8934	[TestFixture]
8935	public class MappingTestAgrBi11OthpabsTblGuid : NDOTest
8936	{
8937	····PersistenceManager pm;
8938	····NDOMapping mapping;
8939	····Class ownClass;
8940	····Class otherClass;
8941	····Class otherDerivedClass;
8942	····[SetUp]
8943	····public void Setup()
8944	····{
8945	········this.pm = PmFactory.NewPersistenceManager();
8946	········this.mapping = pm.NDOMapping;
8947	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidLeft" );
8948	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidRightBase" );
8949	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OthpabsTblGuidRightDerived" );
8950	····}
8951	····[Test]
8952	····public void HasMappingTable()
8953	····{
8954	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8955	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
8956	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
8957	····}
8958	····[Test]
8959	····public void HasTypeColumn()
8960	····{
8961	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
8962	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
8963	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
8964	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
8965	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
8966	····}
8967	····[Test]
8968	····public void HasTypeCode()
8969	····{
8970	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
8971	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
8972	····}
8973	}
8974
8975
8976	[TestFixture]
8977	public class MappingTestAgrDirnOthpabsTblGuid : NDOTest
8978	{
8979	····PersistenceManager pm;
8980	····NDOMapping mapping;
8981	····Class ownClass;
8982	····Class otherClass;
8983	····Class otherDerivedClass;
8984	····[SetUp]
8985	····public void Setup()
8986	····{
8987	········this.pm = PmFactory.NewPersistenceManager();
8988	········this.mapping = pm.NDOMapping;
8989	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidLeft" );
8990	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidRightBase" );
8991	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOthpabsTblGuidRightDerived" );
8992	····}
8993	····[Test]
8994	····public void HasMappingTable()
8995	····{
8996	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
8997	····}
8998	····[Test]
8999	····public void HasTypeColumn()
9000	····{
9001	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9002	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9003	····}
9004	····[Test]
9005	····public void HasTypeCode()
9006	····{
9007	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9008	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9009	····}
9010	}
9011
9012
9013	[TestFixture]
9014	public class MappingTestAgrBin1OthpabsTblGuid : NDOTest
9015	{
9016	····PersistenceManager pm;
9017	····NDOMapping mapping;
9018	····Class ownClass;
9019	····Class otherClass;
9020	····Class otherDerivedClass;
9021	····[SetUp]
9022	····public void Setup()
9023	····{
9024	········this.pm = PmFactory.NewPersistenceManager();
9025	········this.mapping = pm.NDOMapping;
9026	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidLeft" );
9027	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidRightBase" );
9028	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OthpabsTblGuidRightDerived" );
9029	····}
9030	····[Test]
9031	····public void HasMappingTable()
9032	····{
9033	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9034	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9035	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9036	····}
9037	····[Test]
9038	····public void HasTypeColumn()
9039	····{
9040	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9041	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9042	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9043	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9044	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
9045	····}
9046	····[Test]
9047	····public void HasTypeCode()
9048	····{
9049	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9050	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9051	····}
9052	}
9053
9054
9055	[TestFixture]
9056	public class MappingTestAgrBi1nOthpabsNoTblGuid : NDOTest
9057	{
9058	····PersistenceManager pm;
9059	····NDOMapping mapping;
9060	····Class ownClass;
9061	····Class otherClass;
9062	····Class otherDerivedClass;
9063	····[SetUp]
9064	····public void Setup()
9065	····{
9066	········this.pm = PmFactory.NewPersistenceManager();
9067	········this.mapping = pm.NDOMapping;
9068	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidLeft" );
9069	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidRightBase" );
9070	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsNoTblGuidRightDerived" );
9071	····}
9072	····[Test]
9073	····public void HasMappingTable()
9074	····{
9075	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
9076	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
9077	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
9078	····}
9079	····[Test]
9080	····public void HasTypeColumn()
9081	····{
9082	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
9083	····}
9084	····[Test]
9085	····public void HasTypeCode()
9086	····{
9087	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9088	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9089	····}
9090	}
9091
9092
9093	[TestFixture]
9094	public class MappingTestAgrBi1nOthpabsTblGuid : NDOTest
9095	{
9096	····PersistenceManager pm;
9097	····NDOMapping mapping;
9098	····Class ownClass;
9099	····Class otherClass;
9100	····Class otherDerivedClass;
9101	····[SetUp]
9102	····public void Setup()
9103	····{
9104	········this.pm = PmFactory.NewPersistenceManager();
9105	········this.mapping = pm.NDOMapping;
9106	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidLeft" );
9107	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidRightBase" );
9108	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOthpabsTblGuidRightDerived" );
9109	····}
9110	····[Test]
9111	····public void HasMappingTable()
9112	····{
9113	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9114	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9115	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9116	····}
9117	····[Test]
9118	····public void HasTypeColumn()
9119	····{
9120	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9121	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9122	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9123	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9124	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
9125	····}
9126	····[Test]
9127	····public void HasTypeCode()
9128	····{
9129	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9130	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9131	····}
9132	}
9133
9134
9135	[TestFixture]
9136	public class MappingTestAgrBinnOthpabsTblGuid : NDOTest
9137	{
9138	····PersistenceManager pm;
9139	····NDOMapping mapping;
9140	····Class ownClass;
9141	····Class otherClass;
9142	····Class otherDerivedClass;
9143	····[SetUp]
9144	····public void Setup()
9145	····{
9146	········this.pm = PmFactory.NewPersistenceManager();
9147	········this.mapping = pm.NDOMapping;
9148	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidLeft" );
9149	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidRightBase" );
9150	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOthpabsTblGuidRightDerived" );
9151	····}
9152	····[Test]
9153	····public void HasMappingTable()
9154	····{
9155	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9156	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9157	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9158	····}
9159	····[Test]
9160	····public void HasTypeColumn()
9161	····{
9162	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9163	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9164	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9165	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9166	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
9167	····}
9168	····[Test]
9169	····public void HasTypeCode()
9170	····{
9171	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9172	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9173	····}
9174	}
9175
9176
9177	[TestFixture]
9178	public class MappingTestCmpDir1OthpabsNoTblGuid : NDOTest
9179	{
9180	····PersistenceManager pm;
9181	····NDOMapping mapping;
9182	····Class ownClass;
9183	····Class otherClass;
9184	····Class otherDerivedClass;
9185	····[SetUp]
9186	····public void Setup()
9187	····{
9188	········this.pm = PmFactory.NewPersistenceManager();
9189	········this.mapping = pm.NDOMapping;
9190	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidLeft" );
9191	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidRightBase" );
9192	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsNoTblGuidRightDerived" );
9193	····}
9194	····[Test]
9195	····public void HasMappingTable()
9196	····{
9197	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
9198	····}
9199	····[Test]
9200	····public void HasTypeColumn()
9201	····{
9202	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
9203	····}
9204	····[Test]
9205	····public void HasTypeCode()
9206	····{
9207	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9208	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9209	····}
9210	}
9211
9212
9213	[TestFixture]
9214	public class MappingTestCmpDir1OthpabsTblGuid : NDOTest
9215	{
9216	····PersistenceManager pm;
9217	····NDOMapping mapping;
9218	····Class ownClass;
9219	····Class otherClass;
9220	····Class otherDerivedClass;
9221	····[SetUp]
9222	····public void Setup()
9223	····{
9224	········this.pm = PmFactory.NewPersistenceManager();
9225	········this.mapping = pm.NDOMapping;
9226	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidLeft" );
9227	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidRightBase" );
9228	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OthpabsTblGuidRightDerived" );
9229	····}
9230	····[Test]
9231	····public void HasMappingTable()
9232	····{
9233	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9234	····}
9235	····[Test]
9236	····public void HasTypeColumn()
9237	····{
9238	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9239	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9240	····}
9241	····[Test]
9242	····public void HasTypeCode()
9243	····{
9244	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9245	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9246	····}
9247	}
9248
9249
9250	[TestFixture]
9251	public class MappingTestCmpBi11OthpabsNoTblGuid : NDOTest
9252	{
9253	····PersistenceManager pm;
9254	····NDOMapping mapping;
9255	····Class ownClass;
9256	····Class otherClass;
9257	····Class otherDerivedClass;
9258	····[SetUp]
9259	····public void Setup()
9260	····{
9261	········this.pm = PmFactory.NewPersistenceManager();
9262	········this.mapping = pm.NDOMapping;
9263	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidLeft" );
9264	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidRightBase" );
9265	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsNoTblGuidRightDerived" );
9266	····}
9267	····[Test]
9268	····public void HasMappingTable()
9269	····{
9270	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
9271	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
9272	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
9273	····}
9274	····[Test]
9275	····public void HasTypeColumn()
9276	····{
9277	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
9278	····}
9279	····[Test]
9280	····public void HasTypeCode()
9281	····{
9282	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9283	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9284	····}
9285	}
9286
9287
9288	[TestFixture]
9289	public class MappingTestCmpBi11OthpabsTblGuid : NDOTest
9290	{
9291	····PersistenceManager pm;
9292	····NDOMapping mapping;
9293	····Class ownClass;
9294	····Class otherClass;
9295	····Class otherDerivedClass;
9296	····[SetUp]
9297	····public void Setup()
9298	····{
9299	········this.pm = PmFactory.NewPersistenceManager();
9300	········this.mapping = pm.NDOMapping;
9301	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidLeft" );
9302	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidRightBase" );
9303	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OthpabsTblGuidRightDerived" );
9304	····}
9305	····[Test]
9306	····public void HasMappingTable()
9307	····{
9308	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9309	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9310	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9311	····}
9312	····[Test]
9313	····public void HasTypeColumn()
9314	····{
9315	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9316	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9317	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9318	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9319	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
9320	····}
9321	····[Test]
9322	····public void HasTypeCode()
9323	····{
9324	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9325	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9326	····}
9327	}
9328
9329
9330	[TestFixture]
9331	public class MappingTestCmpDirnOthpabsTblGuid : NDOTest
9332	{
9333	····PersistenceManager pm;
9334	····NDOMapping mapping;
9335	····Class ownClass;
9336	····Class otherClass;
9337	····Class otherDerivedClass;
9338	····[SetUp]
9339	····public void Setup()
9340	····{
9341	········this.pm = PmFactory.NewPersistenceManager();
9342	········this.mapping = pm.NDOMapping;
9343	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidLeft" );
9344	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidRightBase" );
9345	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOthpabsTblGuidRightDerived" );
9346	····}
9347	····[Test]
9348	····public void HasMappingTable()
9349	····{
9350	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9351	····}
9352	····[Test]
9353	····public void HasTypeColumn()
9354	····{
9355	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9356	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9357	····}
9358	····[Test]
9359	····public void HasTypeCode()
9360	····{
9361	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9362	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9363	····}
9364	}
9365
9366
9367	[TestFixture]
9368	public class MappingTestCmpBin1OthpabsTblGuid : NDOTest
9369	{
9370	····PersistenceManager pm;
9371	····NDOMapping mapping;
9372	····Class ownClass;
9373	····Class otherClass;
9374	····Class otherDerivedClass;
9375	····[SetUp]
9376	····public void Setup()
9377	····{
9378	········this.pm = PmFactory.NewPersistenceManager();
9379	········this.mapping = pm.NDOMapping;
9380	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidLeft" );
9381	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidRightBase" );
9382	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OthpabsTblGuidRightDerived" );
9383	····}
9384	····[Test]
9385	····public void HasMappingTable()
9386	····{
9387	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9388	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9389	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9390	····}
9391	····[Test]
9392	····public void HasTypeColumn()
9393	····{
9394	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9395	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9396	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9397	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9398	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
9399	····}
9400	····[Test]
9401	····public void HasTypeCode()
9402	····{
9403	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9404	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9405	····}
9406	}
9407
9408
9409	[TestFixture]
9410	public class MappingTestCmpBi1nOthpabsNoTblGuid : NDOTest
9411	{
9412	····PersistenceManager pm;
9413	····NDOMapping mapping;
9414	····Class ownClass;
9415	····Class otherClass;
9416	····Class otherDerivedClass;
9417	····[SetUp]
9418	····public void Setup()
9419	····{
9420	········this.pm = PmFactory.NewPersistenceManager();
9421	········this.mapping = pm.NDOMapping;
9422	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidLeft" );
9423	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidRightBase" );
9424	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsNoTblGuidRightDerived" );
9425	····}
9426	····[Test]
9427	····public void HasMappingTable()
9428	····{
9429	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
9430	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
9431	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
9432	····}
9433	····[Test]
9434	····public void HasTypeColumn()
9435	····{
9436	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
9437	····}
9438	····[Test]
9439	····public void HasTypeCode()
9440	····{
9441	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9442	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9443	····}
9444	}
9445
9446
9447	[TestFixture]
9448	public class MappingTestCmpBi1nOthpabsTblGuid : NDOTest
9449	{
9450	····PersistenceManager pm;
9451	····NDOMapping mapping;
9452	····Class ownClass;
9453	····Class otherClass;
9454	····Class otherDerivedClass;
9455	····[SetUp]
9456	····public void Setup()
9457	····{
9458	········this.pm = PmFactory.NewPersistenceManager();
9459	········this.mapping = pm.NDOMapping;
9460	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidLeft" );
9461	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidRightBase" );
9462	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOthpabsTblGuidRightDerived" );
9463	····}
9464	····[Test]
9465	····public void HasMappingTable()
9466	····{
9467	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9468	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9469	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9470	····}
9471	····[Test]
9472	····public void HasTypeColumn()
9473	····{
9474	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9475	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9476	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9477	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9478	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
9479	····}
9480	····[Test]
9481	····public void HasTypeCode()
9482	····{
9483	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9484	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9485	····}
9486	}
9487
9488
9489	[TestFixture]
9490	public class MappingTestCmpBinnOthpabsTblGuid : NDOTest
9491	{
9492	····PersistenceManager pm;
9493	····NDOMapping mapping;
9494	····Class ownClass;
9495	····Class otherClass;
9496	····Class otherDerivedClass;
9497	····[SetUp]
9498	····public void Setup()
9499	····{
9500	········this.pm = PmFactory.NewPersistenceManager();
9501	········this.mapping = pm.NDOMapping;
9502	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidLeft" );
9503	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidRightBase" );
9504	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOthpabsTblGuidRightDerived" );
9505	····}
9506	····[Test]
9507	····public void HasMappingTable()
9508	····{
9509	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9510	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9511	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9512	····}
9513	····[Test]
9514	····public void HasTypeColumn()
9515	····{
9516	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9517	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9518	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9519	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #1") ;
9520	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Null, "Relation shouldn't have a TypeColumn #2") ;
9521	····}
9522	····[Test]
9523	····public void HasTypeCode()
9524	····{
9525	········Assert.That(this.ownClass.TypeCode != 0, "Class should have a Type Code #1");
9526	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9527	····}
9528	}
9529
9530
9531	[TestFixture]
9532	public class MappingTestAgrDir1OwnpabsOthpabsNoTblGuid : NDOTest
9533	{
9534	····PersistenceManager pm;
9535	····NDOMapping mapping;
9536	····Class ownClass;
9537	····Class otherClass;
9538	····Class ownDerivedClass;
9539	····Class otherDerivedClass;
9540	····[SetUp]
9541	····public void Setup()
9542	····{
9543	········this.pm = PmFactory.NewPersistenceManager();
9544	········this.mapping = pm.NDOMapping;
9545	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidLeftBase" );
9546	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidRightBase" );
9547	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidLeftDerived" );
9548	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsNoTblGuidRightDerived" );
9549	····}
9550	····[Test]
9551	····public void HasMappingTable()
9552	····{
9553	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
9554	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
9555	····}
9556	····[Test]
9557	····public void HasTypeColumn()
9558	····{
9559	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
9560	····}
9561	····[Test]
9562	····public void HasTypeCode()
9563	····{
9564	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9565	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9566	····}
9567	}
9568
9569
9570	[TestFixture]
9571	public class MappingTestAgrDir1OwnpabsOthpabsTblGuid : NDOTest
9572	{
9573	····PersistenceManager pm;
9574	····NDOMapping mapping;
9575	····Class ownClass;
9576	····Class otherClass;
9577	····Class ownDerivedClass;
9578	····Class otherDerivedClass;
9579	····[SetUp]
9580	····public void Setup()
9581	····{
9582	········this.pm = PmFactory.NewPersistenceManager();
9583	········this.mapping = pm.NDOMapping;
9584	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidLeftBase" );
9585	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidRightBase" );
9586	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidLeftDerived" );
9587	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDir1OwnpabsOthpabsTblGuidRightDerived" );
9588	····}
9589	····[Test]
9590	····public void HasMappingTable()
9591	····{
9592	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9593	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
9594	····}
9595	····[Test]
9596	····public void HasTypeColumn()
9597	····{
9598	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
9599	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
9600	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9601	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
9602	····}
9603	····[Test]
9604	····public void HasTypeCode()
9605	····{
9606	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9607	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9608	····}
9609	}
9610
9611
9612	[TestFixture]
9613	public class MappingTestAgrBi11OwnpabsOthpabsNoTblGuid : NDOTest
9614	{
9615	····PersistenceManager pm;
9616	····NDOMapping mapping;
9617	····Class ownClass;
9618	····Class otherClass;
9619	····Class ownDerivedClass;
9620	····Class otherDerivedClass;
9621	····[SetUp]
9622	····public void Setup()
9623	····{
9624	········this.pm = PmFactory.NewPersistenceManager();
9625	········this.mapping = pm.NDOMapping;
9626	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidLeftBase" );
9627	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidRightBase" );
9628	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidLeftDerived" );
9629	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsNoTblGuidRightDerived" );
9630	····}
9631	····[Test]
9632	····public void HasMappingTable()
9633	····{
9634	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
9635	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
9636	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
9637	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
9638	····}
9639	····[Test]
9640	····public void HasTypeColumn()
9641	····{
9642	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
9643	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
9644	····}
9645	····[Test]
9646	····public void HasTypeCode()
9647	····{
9648	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9649	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9650	····}
9651	}
9652
9653
9654	[TestFixture]
9655	public class MappingTestAgrBi11OwnpabsOthpabsTblGuid : NDOTest
9656	{
9657	····PersistenceManager pm;
9658	····NDOMapping mapping;
9659	····Class ownClass;
9660	····Class otherClass;
9661	····Class ownDerivedClass;
9662	····Class otherDerivedClass;
9663	····[SetUp]
9664	····public void Setup()
9665	····{
9666	········this.pm = PmFactory.NewPersistenceManager();
9667	········this.mapping = pm.NDOMapping;
9668	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidLeftBase" );
9669	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidRightBase" );
9670	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidLeftDerived" );
9671	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi11OwnpabsOthpabsTblGuidRightDerived" );
9672	····}
9673	····[Test]
9674	····public void HasMappingTable()
9675	····{
9676	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9677	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
9678	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9679	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9680	····}
9681	····[Test]
9682	····public void HasTypeColumn()
9683	····{
9684	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
9685	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
9686	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9687	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
9688	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9689	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9690	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
9691	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
9692	····}
9693	····[Test]
9694	····public void HasTypeCode()
9695	····{
9696	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9697	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9698	····}
9699	}
9700
9701
9702	[TestFixture]
9703	public class MappingTestAgrDirnOwnpabsOthpabsTblGuid : NDOTest
9704	{
9705	····PersistenceManager pm;
9706	····NDOMapping mapping;
9707	····Class ownClass;
9708	····Class otherClass;
9709	····Class ownDerivedClass;
9710	····Class otherDerivedClass;
9711	····[SetUp]
9712	····public void Setup()
9713	····{
9714	········this.pm = PmFactory.NewPersistenceManager();
9715	········this.mapping = pm.NDOMapping;
9716	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidLeftBase" );
9717	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidRightBase" );
9718	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidLeftDerived" );
9719	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrDirnOwnpabsOthpabsTblGuidRightDerived" );
9720	····}
9721	····[Test]
9722	····public void HasMappingTable()
9723	····{
9724	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9725	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
9726	····}
9727	····[Test]
9728	····public void HasTypeColumn()
9729	····{
9730	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
9731	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
9732	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9733	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
9734	····}
9735	····[Test]
9736	····public void HasTypeCode()
9737	····{
9738	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9739	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9740	····}
9741	}
9742
9743
9744	[TestFixture]
9745	public class MappingTestAgrBin1OwnpabsOthpabsTblGuid : NDOTest
9746	{
9747	····PersistenceManager pm;
9748	····NDOMapping mapping;
9749	····Class ownClass;
9750	····Class otherClass;
9751	····Class ownDerivedClass;
9752	····Class otherDerivedClass;
9753	····[SetUp]
9754	····public void Setup()
9755	····{
9756	········this.pm = PmFactory.NewPersistenceManager();
9757	········this.mapping = pm.NDOMapping;
9758	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidLeftBase" );
9759	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidRightBase" );
9760	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidLeftDerived" );
9761	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBin1OwnpabsOthpabsTblGuidRightDerived" );
9762	····}
9763	····[Test]
9764	····public void HasMappingTable()
9765	····{
9766	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9767	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
9768	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9769	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9770	····}
9771	····[Test]
9772	····public void HasTypeColumn()
9773	····{
9774	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
9775	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
9776	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9777	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
9778	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9779	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9780	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
9781	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
9782	····}
9783	····[Test]
9784	····public void HasTypeCode()
9785	····{
9786	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9787	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9788	····}
9789	}
9790
9791
9792	[TestFixture]
9793	public class MappingTestAgrBi1nOwnpabsOthpabsTblGuid : NDOTest
9794	{
9795	····PersistenceManager pm;
9796	····NDOMapping mapping;
9797	····Class ownClass;
9798	····Class otherClass;
9799	····Class ownDerivedClass;
9800	····Class otherDerivedClass;
9801	····[SetUp]
9802	····public void Setup()
9803	····{
9804	········this.pm = PmFactory.NewPersistenceManager();
9805	········this.mapping = pm.NDOMapping;
9806	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidLeftBase" );
9807	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidRightBase" );
9808	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidLeftDerived" );
9809	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBi1nOwnpabsOthpabsTblGuidRightDerived" );
9810	····}
9811	····[Test]
9812	····public void HasMappingTable()
9813	····{
9814	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9815	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
9816	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9817	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9818	····}
9819	····[Test]
9820	····public void HasTypeColumn()
9821	····{
9822	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
9823	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
9824	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9825	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
9826	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9827	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9828	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
9829	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
9830	····}
9831	····[Test]
9832	····public void HasTypeCode()
9833	····{
9834	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9835	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9836	····}
9837	}
9838
9839
9840	[TestFixture]
9841	public class MappingTestAgrBinnOwnpabsOthpabsTblGuid : NDOTest
9842	{
9843	····PersistenceManager pm;
9844	····NDOMapping mapping;
9845	····Class ownClass;
9846	····Class otherClass;
9847	····Class ownDerivedClass;
9848	····Class otherDerivedClass;
9849	····[SetUp]
9850	····public void Setup()
9851	····{
9852	········this.pm = PmFactory.NewPersistenceManager();
9853	········this.mapping = pm.NDOMapping;
9854	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidLeftBase" );
9855	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidRightBase" );
9856	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidLeftDerived" );
9857	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.AgrBinnOwnpabsOthpabsTblGuidRightDerived" );
9858	····}
9859	····[Test]
9860	····public void HasMappingTable()
9861	····{
9862	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9863	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
9864	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
9865	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
9866	····}
9867	····[Test]
9868	····public void HasTypeColumn()
9869	····{
9870	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
9871	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
9872	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9873	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
9874	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
9875	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
9876	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
9877	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
9878	····}
9879	····[Test]
9880	····public void HasTypeCode()
9881	····{
9882	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9883	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9884	····}
9885	}
9886
9887
9888	[TestFixture]
9889	public class MappingTestCmpDir1OwnpabsOthpabsNoTblGuid : NDOTest
9890	{
9891	····PersistenceManager pm;
9892	····NDOMapping mapping;
9893	····Class ownClass;
9894	····Class otherClass;
9895	····Class ownDerivedClass;
9896	····Class otherDerivedClass;
9897	····[SetUp]
9898	····public void Setup()
9899	····{
9900	········this.pm = PmFactory.NewPersistenceManager();
9901	········this.mapping = pm.NDOMapping;
9902	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidLeftBase" );
9903	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidRightBase" );
9904	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidLeftDerived" );
9905	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsNoTblGuidRightDerived" );
9906	····}
9907	····[Test]
9908	····public void HasMappingTable()
9909	····{
9910	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
9911	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
9912	····}
9913	····[Test]
9914	····public void HasTypeColumn()
9915	····{
9916	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
9917	····}
9918	····[Test]
9919	····public void HasTypeCode()
9920	····{
9921	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9922	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9923	····}
9924	}
9925
9926
9927	[TestFixture]
9928	public class MappingTestCmpDir1OwnpabsOthpabsTblGuid : NDOTest
9929	{
9930	····PersistenceManager pm;
9931	····NDOMapping mapping;
9932	····Class ownClass;
9933	····Class otherClass;
9934	····Class ownDerivedClass;
9935	····Class otherDerivedClass;
9936	····[SetUp]
9937	····public void Setup()
9938	····{
9939	········this.pm = PmFactory.NewPersistenceManager();
9940	········this.mapping = pm.NDOMapping;
9941	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidLeftBase" );
9942	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidRightBase" );
9943	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidLeftDerived" );
9944	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDir1OwnpabsOthpabsTblGuidRightDerived" );
9945	····}
9946	····[Test]
9947	····public void HasMappingTable()
9948	····{
9949	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
9950	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
9951	····}
9952	····[Test]
9953	····public void HasTypeColumn()
9954	····{
9955	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
9956	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
9957	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
9958	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
9959	····}
9960	····[Test]
9961	····public void HasTypeCode()
9962	····{
9963	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
9964	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
9965	····}
9966	}
9967
9968
9969	[TestFixture]
9970	public class MappingTestCmpBi11OwnpabsOthpabsNoTblGuid : NDOTest
9971	{
9972	····PersistenceManager pm;
9973	····NDOMapping mapping;
9974	····Class ownClass;
9975	····Class otherClass;
9976	····Class ownDerivedClass;
9977	····Class otherDerivedClass;
9978	····[SetUp]
9979	····public void Setup()
9980	····{
9981	········this.pm = PmFactory.NewPersistenceManager();
9982	········this.mapping = pm.NDOMapping;
9983	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidLeftBase" );
9984	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidRightBase" );
9985	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidLeftDerived" );
9986	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsNoTblGuidRightDerived" );
9987	····}
9988	····[Test]
9989	····public void HasMappingTable()
9990	····{
9991	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #5") ;
9992	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #6") ;
9993	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #7") ;
9994	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Null, "Relation shouldn't have a MappingTable #8") ;
9995	····}
9996	····[Test]
9997	····public void HasTypeColumn()
9998	····{
9999	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #9") ;
10000	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #10") ;
10001	····}
10002	····[Test]
10003	····public void HasTypeCode()
10004	····{
10005	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10006	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10007	····}
10008	}
10009
10010
10011	[TestFixture]
10012	public class MappingTestCmpBi11OwnpabsOthpabsTblGuid : NDOTest
10013	{
10014	····PersistenceManager pm;
10015	····NDOMapping mapping;
10016	····Class ownClass;
10017	····Class otherClass;
10018	····Class ownDerivedClass;
10019	····Class otherDerivedClass;
10020	····[SetUp]
10021	····public void Setup()
10022	····{
10023	········this.pm = PmFactory.NewPersistenceManager();
10024	········this.mapping = pm.NDOMapping;
10025	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidLeftBase" );
10026	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidRightBase" );
10027	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidLeftDerived" );
10028	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi11OwnpabsOthpabsTblGuidRightDerived" );
10029	····}
10030	····[Test]
10031	····public void HasMappingTable()
10032	····{
10033	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
10034	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
10035	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
10036	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
10037	····}
10038	····[Test]
10039	····public void HasTypeColumn()
10040	····{
10041	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
10042	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
10043	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
10044	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
10045	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
10046	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
10047	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
10048	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
10049	····}
10050	····[Test]
10051	····public void HasTypeCode()
10052	····{
10053	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10054	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10055	····}
10056	}
10057
10058
10059	[TestFixture]
10060	public class MappingTestCmpDirnOwnpabsOthpabsTblGuid : NDOTest
10061	{
10062	····PersistenceManager pm;
10063	····NDOMapping mapping;
10064	····Class ownClass;
10065	····Class otherClass;
10066	····Class ownDerivedClass;
10067	····Class otherDerivedClass;
10068	····[SetUp]
10069	····public void Setup()
10070	····{
10071	········this.pm = PmFactory.NewPersistenceManager();
10072	········this.mapping = pm.NDOMapping;
10073	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidLeftBase" );
10074	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidRightBase" );
10075	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidLeftDerived" );
10076	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpDirnOwnpabsOthpabsTblGuidRightDerived" );
10077	····}
10078	····[Test]
10079	····public void HasMappingTable()
10080	····{
10081	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
10082	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
10083	····}
10084	····[Test]
10085	····public void HasTypeColumn()
10086	····{
10087	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
10088	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
10089	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
10090	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
10091	····}
10092	····[Test]
10093	····public void HasTypeCode()
10094	····{
10095	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10096	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10097	····}
10098	}
10099
10100
10101	[TestFixture]
10102	public class MappingTestCmpBin1OwnpabsOthpabsTblGuid : NDOTest
10103	{
10104	····PersistenceManager pm;
10105	····NDOMapping mapping;
10106	····Class ownClass;
10107	····Class otherClass;
10108	····Class ownDerivedClass;
10109	····Class otherDerivedClass;
10110	····[SetUp]
10111	····public void Setup()
10112	····{
10113	········this.pm = PmFactory.NewPersistenceManager();
10114	········this.mapping = pm.NDOMapping;
10115	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidLeftBase" );
10116	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidRightBase" );
10117	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidLeftDerived" );
10118	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBin1OwnpabsOthpabsTblGuidRightDerived" );
10119	····}
10120	····[Test]
10121	····public void HasMappingTable()
10122	····{
10123	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
10124	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
10125	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
10126	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
10127	····}
10128	····[Test]
10129	····public void HasTypeColumn()
10130	····{
10131	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
10132	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
10133	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
10134	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
10135	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
10136	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
10137	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
10138	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
10139	····}
10140	····[Test]
10141	····public void HasTypeCode()
10142	····{
10143	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10144	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10145	····}
10146	}
10147
10148
10149	[TestFixture]
10150	public class MappingTestCmpBi1nOwnpabsOthpabsTblGuid : NDOTest
10151	{
10152	····PersistenceManager pm;
10153	····NDOMapping mapping;
10154	····Class ownClass;
10155	····Class otherClass;
10156	····Class ownDerivedClass;
10157	····Class otherDerivedClass;
10158	····[SetUp]
10159	····public void Setup()
10160	····{
10161	········this.pm = PmFactory.NewPersistenceManager();
10162	········this.mapping = pm.NDOMapping;
10163	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidLeftBase" );
10164	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidRightBase" );
10165	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidLeftDerived" );
10166	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBi1nOwnpabsOthpabsTblGuidRightDerived" );
10167	····}
10168	····[Test]
10169	····public void HasMappingTable()
10170	····{
10171	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
10172	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
10173	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
10174	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
10175	····}
10176	····[Test]
10177	····public void HasTypeColumn()
10178	····{
10179	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
10180	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
10181	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
10182	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
10183	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
10184	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
10185	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
10186	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
10187	····}
10188	····[Test]
10189	····public void HasTypeCode()
10190	····{
10191	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10192	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10193	····}
10194	}
10195
10196
10197	[TestFixture]
10198	public class MappingTestCmpBinnOwnpabsOthpabsTblGuid : NDOTest
10199	{
10200	····PersistenceManager pm;
10201	····NDOMapping mapping;
10202	····Class ownClass;
10203	····Class otherClass;
10204	····Class ownDerivedClass;
10205	····Class otherDerivedClass;
10206	····[SetUp]
10207	····public void Setup()
10208	····{
10209	········this.pm = PmFactory.NewPersistenceManager();
10210	········this.mapping = pm.NDOMapping;
10211	········this.ownClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidLeftBase" );
10212	········this.otherClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidRightBase" );
10213	········this.ownDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidLeftDerived" );
10214	········this.otherDerivedClass = this.mapping.FindClass( "RelationTestClasses.CmpBinnOwnpabsOthpabsTblGuidRightDerived" );
10215	····}
10216	····[Test]
10217	····public void HasMappingTable()
10218	····{
10219	Assert. That( ownClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #1") ;
10220	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #2") ;
10221	Assert. That( otherClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #3") ;
10222	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable, Is. Not. Null, "Relation should have a MappingTable #4") ;
10223	····}
10224	····[Test]
10225	····public void HasTypeColumn()
10226	····{
10227	Assert. That( ownClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #1") ;
10228	Assert. That( ownDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #2") ;
10229	Assert. That( ownClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #3") ;
10230	Assert. That( ownDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #4") ;
10231	Assert. That( otherClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #5") ;
10232	Assert. That( otherDerivedClass. Relations. First( ) . ForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #6") ;
10233	Assert. That( otherClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #7") ;
10234	Assert. That( otherDerivedClass. Relations. First( ) . MappingTable. ChildForeignKeyTypeColumnName, Is. Not. Null, "Relation should have a TypeColumn #8") ;
10235	····}
10236	····[Test]
10237	····public void HasTypeCode()
10238	····{
10239	········Assert.That(this.ownDerivedClass.TypeCode != 0, "Class should have a Type Code #3");
10240	········Assert.That(this.otherDerivedClass.TypeCode != 0, "Class should have a Type Code #4");
10241	····}
10242	}
10243
10244
10245
10246	}
10247

Cookie Info