mcs/class/System.Web.DynamicData/Test/System.Web.DynamicData/MetaColumnTest.cs

   1 //
   2 // MetaColumnTest.cs
   3 //
   4 // Authors:
   5 //      Marek Habersack <mhabersack@novell.com>
   6 //
   7 // Copyright (C) 2009 Novell Inc. http://novell.com
   8 //
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29 using System;
  30 using System.Collections;
  31 using System.Collections.Generic;
  32 using System.Collections.ObjectModel;
  33 using System.Collections.Specialized;
  34 using System.ComponentModel.DataAnnotations;
  35 using System.Data.SqlClient;
  36 using System.Data.Linq;
  37 using System.Data.Linq.Mapping;
  38 using System.Globalization;
  39 using System.Linq;
  40 using System.Reflection;
  41 using System.Security.Permissions;
  42 using System.Security.Principal;
  43 using System.Web;
  44 using System.Web.UI;
  45 using System.Web.DynamicData;
  46 using System.Web.DynamicData.ModelProviders;
  47 using System.Web.Routing;
  48
  49 using NUnit.Framework;
  50 using NUnit.Mocks;
  51 using MonoTests.stand_alone.WebHarness;
  52 using MonoTests.SystemWeb.Framework;
  53 using MonoTests.Common;
  54 using MonoTests.ModelProviders;
  55
  56 using MetaModel = System.Web.DynamicData.MetaModel;
  57 using MetaTable = System.Web.DynamicData.MetaTable;
  58
  59 namespace MonoTests.System.Web.DynamicData
  60 {
  61         // IMPORTANT
  62         //
  63         // ALL tests which make use of RouteTable.Routes _MUST_ clear the collection before running
  64         //
  65         [TestFixture]
  66         public class MetaColumnTest
  67         {
  68                 DynamicDataContainerModelProvider <TestDataContext> dynamicModelProvider;
  69                 DynamicDataContainerModelProvider<TestDataContext2> dynamicModelProviderNoScaffold;
  70
  71                 [TestFixtureSetUp]
  72                 public void SetUp ()
  73                 {
  74                         dynamicModelProvider = new DynamicDataContainerModelProvider <TestDataContext> ();
  75                         Utils.RegisterContext (dynamicModelProvider, new ContextConfiguration () { ScaffoldAllTables = true });
  76
  77                         dynamicModelProviderNoScaffold = new DynamicDataContainerModelProvider <TestDataContext2> ();
  78                         Utils.RegisterContext (dynamicModelProviderNoScaffold, new ContextConfiguration () { ScaffoldAllTables = false }, false);
  79                 }
  80
  81                 [Test]
  82                 public void ApplyFormattingInEditMode ()
  83                 {
  84                         MetaModel m = Utils.CommonInitialize ();
  85                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
  86                         MetaColumn mc = t.GetColumn ("ColumnNoAttributes");
  87                         Assert.IsNotNull (mc, "#A1");
  88                         Assert.AreEqual (false, mc.ApplyFormatInEditMode, "#A1-1");
  89
  90                         mc = t.GetColumn ("ColumnFormatInEditMode");
  91                         Assert.IsNotNull (mc, "#A2");
  92                         Assert.AreEqual (true, mc.ApplyFormatInEditMode, "#A2-1");
  93
  94                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
  95                         mc = t.GetColumn ("Column1");
  96                         Assert.IsNotNull (mc, "#C1");
  97                         Assert.AreEqual (true, mc.ApplyFormatInEditMode, "#C1-1");
  98
  99                         mc = t.GetColumn ("Column2");
 100                         Assert.IsNotNull (mc, "#C2");
 101                         Assert.AreEqual (true, mc.ApplyFormatInEditMode, "#C2-1");
 102                 }
 103
 104                 [Test]
 105                 public void Attributes ()
 106                 {
 107                         MetaModel m = Utils.CommonInitialize ();
 108
 109                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 110                         MetaColumn mc = t.GetColumn ("ColumnNoAttributes");
 111                         Assert.IsNotNull (mc, "#A1");
 112                         Assert.IsNotNull (mc.Attributes, "#A2");
 113                         Assert.AreEqual (5, mc.Attributes.Count, "#A3");
 114                         Assert.IsTrue (mc.IsRequired, "#A3-1");
 115
 116                         mc = t.GetColumn ("ColumnFormatInEditMode");
 117                         Assert.IsNotNull (mc, "#A4");
 118                         Assert.IsNotNull (mc.Attributes, "#A4-1");
 119                         Assert.AreEqual (6, mc.Attributes.Count, "#A4-2");
 120                         Assert.AreEqual (1, mc.Attributes.OfType <DisplayFormatAttribute> ().Count (), "#A4-3");
 121
 122                         mc = t.GetColumn ("ColumnWithDataType");
 123                         Assert.IsNotNull (mc, "#A5");
 124                         Assert.IsNotNull (mc.Attributes, "#A5-1");
 125                         Assert.AreEqual (6, mc.Attributes.Count, "#A5-2");
 126                         Assert.AreEqual (1, mc.Attributes.OfType<DataTypeAttribute> ().Count (), "#A5-3");
 127
 128                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 129                         mc = t.GetColumn ("Column1");
 130                         Assert.IsNotNull (mc, "#B1");
 131                         Assert.IsNotNull (mc.Attributes, "#B1-1");
 132                         Assert.AreEqual (8, mc.Attributes.Count, "#B1-2");
 133                         Assert.AreEqual (1, mc.Attributes.OfType<DisplayFormatAttribute> ().Count (), "#B1-3");
 134
 135                         mc = t.GetColumn ("Column2");
 136                         Assert.IsNotNull (mc, "#B2");
 137                         Assert.IsNotNull (mc.Attributes, "#B2-1");
 138                         Assert.AreEqual (7, mc.Attributes.Count, "#B2-2");
 139                         Assert.AreEqual (1, mc.Attributes.OfType<DataTypeAttribute> ().Count (), "#B2-3");
 140                 }
 141
 142                 [Test]
 143                 public void ColumnType ()
 144                 {
 145                         MetaModel m = Utils.CommonInitialize ();
 146
 147                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 148                         MetaColumn mc = t.GetColumn ("ColumnNoAttributes");
 149                         Assert.IsNotNull (mc, "#A1");
 150                         Assert.AreEqual (typeof (string), mc.ColumnType, "#A3");
 151
 152                         mc = t.GetColumn ("ColumnFormatInEditMode");
 153                         Assert.IsNotNull (mc, "#A4");
 154                         Assert.IsNotNull (mc.Attributes, "#A4-1");
 155                         Assert.AreEqual (typeof (string), mc.ColumnType, "#A4-2");
 156
 157                         mc = t.GetColumn ("ColumnWithDataType");
 158                         Assert.IsNotNull (mc, "#A5");
 159                         Assert.IsNotNull (mc.Attributes, "#A5-1");
 160                         Assert.AreEqual (typeof (string), mc.ColumnType, "#A5-2");
 161
 162                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 163                         mc = t.GetColumn ("Column1");
 164                         Assert.IsNotNull (mc, "#B1");
 165                         Assert.IsNotNull (mc.Attributes, "#B1-1");
 166                         Assert.AreEqual (typeof (string), mc.ColumnType, "#B1-2");
 167
 168                         mc = t.GetColumn ("Column2");
 169                         Assert.IsNotNull (mc, "#B2");
 170                         Assert.IsNotNull (mc.Attributes, "#B2-1");
 171                         Assert.AreEqual (typeof (string), mc.ColumnType, "#B2-2");
 172
 173                         mc = t.GetColumn ("Column3");
 174                         Assert.IsNotNull (mc, "#C2");
 175                         Assert.IsNotNull (mc.Attributes, "#C2-1");
 176                         Assert.AreEqual (typeof (string), mc.ColumnType, "#C2-2");
 177                 }
 178
 179                 [Test]
 180                 public void ConvertEmptyStringToNull ()
 181                 {
 182                         MetaModel m = Utils.CommonInitialize ();
 183
 184                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 185                         MetaColumn mc = t.GetColumn ("ColumnNoAttributes");
 186                         Assert.IsNotNull (mc, "#A1");
 187                         Assert.AreEqual (true, mc.ConvertEmptyStringToNull, "#A1-1");
 188
 189                         mc = t.GetColumn ("ColumnFormatInEditMode");
 190                         Assert.IsNotNull (mc, "#A2");
 191                         Assert.AreEqual (true, mc.ConvertEmptyStringToNull, "#A2-1");
 192
 193                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 194                         mc = t.GetColumn ("Column1");
 195                         Assert.IsNotNull (mc, "#C1");
 196                         Assert.AreEqual (true, mc.ConvertEmptyStringToNull, "#C1-1");
 197
 198                         mc = t.GetColumn ("Column2");
 199                         Assert.IsNotNull (mc, "#C2");
 200                         Assert.AreEqual (true, mc.ConvertEmptyStringToNull, "#C2-1");
 201                 }
 202
 203                 [Test]
 204                 public void DataFormatString ()
 205                 {
 206                         MetaModel m = Utils.CommonInitialize ();
 207
 208                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 209                         MetaColumn mc = t.GetColumn ("ColumnNoAttributes");
 210                         Assert.IsNotNull (mc, "#A1");
 211                         Assert.AreEqual (String.Empty, mc.DataFormatString, "#A1-1");
 212
 213                         mc = t.GetColumn ("ColumnFormatInEditMode");
 214                         Assert.IsNotNull (mc, "#A2");
 215                         Assert.AreEqual ("Item: {0}", mc.DataFormatString, "#A2-1");
 216
 217                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 218                         mc = t.GetColumn ("Column1");
 219                         Assert.IsNotNull (mc, "#C1");
 220                         Assert.AreEqual ("Item: {0}", mc.DataFormatString, "#C1-1");
 221
 222                         mc = t.GetColumn ("Column2");
 223                         Assert.IsNotNull (mc, "#C2");
 224                         Assert.AreEqual ("{0:t}", mc.DataFormatString, "#C2-1");
 225                 }
 226
 227                 [Test]
 228                 public void DataTypeAttribute ()
 229                 {
 230                         MetaModel m = Utils.CommonInitialize ();
 231
 232                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 233                         MetaColumn mc = t.GetColumn ("ColumnNoAttributes");
 234
 235                         Assert.IsNotNull (mc, "#A1");
 236                         Assert.IsNotNull (mc.DataTypeAttribute, "#A1-1");
 237
 238                         mc = t.GetColumn ("ColumnWithDataType");
 239                         Assert.IsNotNull (mc, "#A2");
 240                         Assert.IsNotNull (mc.DataTypeAttribute, "#A2-1");
 241                         Assert.AreEqual (DataType.EmailAddress, mc.DataTypeAttribute.DataType, "#A2-2");
 242
 243                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 244                         mc = t.GetColumn ("Column2");
 245                         Assert.IsNotNull (mc, "#C1");
 246                         Assert.IsNotNull (mc.DataTypeAttribute, "#C1-1");
 247                         Assert.AreEqual (DataType.Time, mc.DataTypeAttribute.DataType, "#C1-2");
 248
 249                         mc = t.GetColumn ("Column3");
 250                         Assert.IsNotNull (mc, "#C2");
 251                         Assert.IsNotNull (mc.DataTypeAttribute, "#C2-1");
 252                         Assert.AreEqual (DataType.Currency, mc.DataTypeAttribute.DataType, "#C2-2");
 253
 254                         // Check default types for columns not decorated with the attribute
 255                         t = m.Tables[TestDataContext.TableBazDataTypeDefaultTypes];
 256                         mc = t.GetColumn ("Char_Column");
 257                         Assert.IsNotNull (mc, "#D1");
 258                         Assert.IsNull (mc.DataTypeAttribute, "#D1-1");
 259
 260                         mc = t.GetColumn ("Byte_Column");
 261                         Assert.IsNotNull (mc, "#D2");
 262                         Assert.IsNull (mc.DataTypeAttribute, "#D2-1");
 263
 264                         mc = t.GetColumn ("Int_Column");
 265                         Assert.IsNotNull (mc, "#D3");
 266                         Assert.IsNull (mc.DataTypeAttribute, "#D3-1");
 267
 268                         mc = t.GetColumn ("Long_Column");
 269                         Assert.IsNotNull (mc, "#D4");
 270                         Assert.IsNull (mc.DataTypeAttribute, "#D4-1");
 271
 272                         mc = t.GetColumn ("Bool_Column");
 273                         Assert.IsNotNull (mc, "#D5");
 274                         Assert.IsNull (mc.DataTypeAttribute, "#D5-1");
 275
 276                         mc = t.GetColumn ("String_Column");
 277                         Assert.IsNotNull (mc, "#D6");
 278                         Assert.IsNotNull (mc.DataTypeAttribute, "#D6-1");
 279                         Assert.AreEqual (DataType.Text, mc.DataTypeAttribute.DataType, "#D6-2");
 280
 281                         mc = t.GetColumn ("DateTime_Column");
 282                         Assert.IsNotNull (mc, "#D7");
 283                         Assert.IsNull (mc.DataTypeAttribute, "#D7-1");
 284
 285                         mc = t.GetColumn ("FooEmpty_Column");
 286                         Assert.IsNotNull (mc, "#D7");
 287                         Assert.IsNull (mc.DataTypeAttribute, "#D7-1");
 288                 }
 289
 290                 [Test]
 291                 public void DefaultValue ()
 292                 {
 293                         MetaModel m = Utils.CommonInitialize ();
 294
 295                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 296                         MetaColumn mc = t.GetColumn ("ColumnFormatInEditMode");
 297                         Assert.IsNotNull (mc, "#A1");
 298                         Assert.AreEqual (null, mc.DefaultValue, "#A1-1");
 299
 300                         mc = t.GetColumn ("ColumnWithDefaultStringValue");
 301                         Assert.IsNotNull (mc, "#A2");
 302                         Assert.IsNotNull (mc.DefaultValue, "#A2-1");
 303                         Assert.AreEqual (typeof (string), mc.DefaultValue.GetType (), "#A2-2");
 304                         Assert.AreEqual ("Value", mc.DefaultValue, "#A2-3");
 305
 306                         mc = t.GetColumn ("ColumnWithDefaultLongValue");
 307                         Assert.IsNotNull (mc, "#A3");
 308                         Assert.IsNotNull (mc.DefaultValue, "#A3-1");
 309                         Assert.AreEqual (typeof (long), mc.DefaultValue.GetType (), "#A3-2");
 310                         Assert.AreEqual (12345, mc.DefaultValue, "#A3-3");
 311
 312                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 313                         mc = t.GetColumn ("Column1");
 314                         Assert.IsNotNull (mc, "#B1");
 315                         Assert.IsNotNull (mc.DefaultValue, "#B1-1");
 316                         Assert.AreEqual (typeof (string), mc.DefaultValue.GetType (), "#B1-2");
 317                         Assert.AreEqual ("Value", mc.DefaultValue, "#B1-3");
 318
 319                         mc = t.GetColumn ("Column2");
 320                         Assert.IsNotNull (mc, "#B2");
 321                         Assert.IsNotNull (mc.DefaultValue, "#B2-1");
 322                         Assert.AreEqual (typeof (string), mc.DefaultValue.GetType (), "#B2-2");
 323                         Assert.AreEqual ("Value", mc.DefaultValue, "#B2-3");
 324
 325                         mc = t.GetColumn ("Column3");
 326                         Assert.IsNotNull (mc, "#B3");
 327                         Assert.IsNotNull (mc.DefaultValue, "#B3-1");
 328                         Assert.AreEqual (typeof (int), mc.DefaultValue.GetType (), "#B3-2");
 329                         Assert.AreEqual (123, mc.DefaultValue, "#B3-3");
 330                 }
 331
 332                 [Test]
 333                 public void Description ()
 334                 {
 335                         MetaModel m = Utils.CommonInitialize ();
 336
 337                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 338                         MetaColumn mc = t.GetColumn ("ColumnWithDescription");
 339                         Assert.IsNotNull (mc, "#A1");
 340                         Assert.IsNotNull (mc.Description, "#A1-1");
 341                         Assert.AreEqual ("Description", mc.Description, "#A1-2");
 342
 343                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 344                         mc = t.GetColumn ("Column1");
 345                         Assert.IsNotNull (mc, "#B1");
 346                         Assert.IsNotNull (mc.Description, "#B1-1");
 347                         Assert.AreEqual ("Description", mc.Description, "#B1-2");
 348
 349                         mc = t.GetColumn ("Column3");
 350                         Assert.IsNotNull (mc, "#B2");
 351                         Assert.IsNotNull (mc.Description, "#B2-1");
 352                         Assert.AreEqual ("Description", mc.Description, "#B2-2");
 353                 }
 354
 355                 [Test]
 356                 public void DisplayName ()
 357                 {
 358                         MetaModel m = Utils.CommonInitialize ();
 359
 360                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 361                         MetaColumn mc = t.GetColumn ("ColumnWithDisplayName");
 362                         Assert.IsNotNull (mc, "#A1");
 363                         Assert.AreEqual ("Display Name", mc.DisplayName, "#A1-1");
 364
 365                         mc = t.GetColumn ("ColumnNoAttributes");
 366                         Assert.IsNotNull (mc, "#A2");
 367                         Assert.AreEqual ("ColumnNoAttributes", mc.DisplayName, "#A2-1");
 368
 369                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 370                         mc = t.GetColumn ("Column3");
 371                         Assert.IsNotNull (mc, "#B1");
 372                         Assert.AreEqual ("Column three", mc.DisplayName, "#B1-1");
 373
 374                         mc = t.GetColumn ("Column4");
 375                         Assert.IsNotNull (mc, "#B2");
 376                         Assert.AreEqual ("Column four", mc.DisplayName, "#B2-1");
 377                 }
 378
 379                 [Test]
 380                 public void EntityTypeProperty ()
 381                 {
 382                         MetaModel m = Utils.CommonInitialize ();
 383
 384                         MetaTable t = m.Tables[TestDataContext.TableFooWithMetadataType];
 385                         MetaColumn mc = t.GetColumn ("Column1");
 386                         Assert.IsNotNull (mc, "#A1");
 387                         Assert.IsNotNull (mc.EntityTypeProperty, "#A2");
 388                         Assert.AreEqual ("Column1", mc.EntityTypeProperty.Name, "#A3");
 389                         Assert.AreEqual (mc.Provider.EntityTypeProperty, mc.EntityTypeProperty, "#A4");
 390                 }
 391
 392                 [Test]
 393                 public void HtmlEncode ()
 394                 {
 395                         MetaModel m = Utils.CommonInitialize ();
 396
 397                         MetaTable t = m.Tables[TestDataContext.TableFooWithMetadataType];
 398                         MetaColumn mc = t.GetColumn ("Column1");
 399                         Assert.IsNotNull (mc, "#A1");
 400                         Assert.AreEqual (true, mc.HtmlEncode, "#A1-1");
 401
 402                         mc = t.GetColumn ("Column2");
 403                         Assert.IsNotNull (mc, "#A2");
 404                         Assert.AreEqual (true, mc.HtmlEncode, "#A2-1");
 405
 406                         mc = t.GetColumn ("Column3");
 407                         Assert.IsNotNull (mc, "#A3");
 408                         Assert.AreEqual (true, mc.HtmlEncode, "#A3-1");
 409
 410                         mc = t.GetColumn ("Column4");
 411                         Assert.IsNotNull (mc, "#A4");
 412                         Assert.AreEqual (true, mc.HtmlEncode, "#A4-1");
 413                 }
 414
 415                 [Test]
 416                 public void IsBinaryData ()
 417                 {
 418                         MetaModel m = Utils.CommonInitialize ();
 419
 420                         MetaTable t = m.Tables[TestDataContext.TableBazDataTypeDefaultTypes];
 421                         MetaColumn mc = t.GetColumn ("Char_Column");
 422                         Assert.IsNotNull (mc, "#A1");
 423                         Assert.AreEqual (false, mc.IsBinaryData, "#A2");
 424
 425                         mc = t.GetColumn ("Byte_Column");
 426                         Assert.IsNotNull (mc, "#A2");
 427                         Assert.AreEqual (false, mc.IsBinaryData, "#A2-1");
 428
 429                         mc = t.GetColumn ("Int_Column");
 430                         Assert.IsNotNull (mc, "#A3");
 431                         Assert.AreEqual (false, mc.IsBinaryData, "#A3-1");
 432
 433                         mc = t.GetColumn ("Long_Column");
 434                         Assert.IsNotNull (mc, "#A4");
 435                         Assert.AreEqual (false, mc.IsBinaryData, "#A4-1");
 436
 437                         mc = t.GetColumn ("Bool_Column");
 438                         Assert.IsNotNull (mc, "#A5");
 439                         Assert.AreEqual (false, mc.IsBinaryData, "#A5-1");
 440
 441                         mc = t.GetColumn ("String_Column");
 442                         Assert.IsNotNull (mc, "#A6");
 443                         Assert.AreEqual (false, mc.IsBinaryData, "#A6-1");
 444
 445                         mc = t.GetColumn ("DateTime_Column");
 446                         Assert.IsNotNull (mc, "#A7");
 447                         Assert.AreEqual (false, mc.IsBinaryData, "#A7-1");
 448
 449                         mc = t.GetColumn ("FooEmpty_Column");
 450                         Assert.IsNotNull (mc, "#A8");
 451                         Assert.AreEqual (false, mc.IsBinaryData, "#A8-1");
 452
 453                         mc = t.GetColumn ("Object_Column");
 454                         Assert.IsNotNull (mc, "#A9");
 455                         Assert.AreEqual (false, mc.IsBinaryData, "#A9-1");
 456
 457                         mc = t.GetColumn ("ByteArray_Column");
 458                         Assert.IsNotNull (mc, "#A10");
 459                         Assert.AreEqual (true, mc.IsBinaryData, "#A10-1");
 460
 461                         mc = t.GetColumn ("IntArray_Column");
 462                         Assert.IsNotNull (mc, "#A11");
 463                         Assert.AreEqual (false, mc.IsBinaryData, "#A11-1");
 464
 465                         mc = t.GetColumn ("StringArray_Column");
 466                         Assert.IsNotNull (mc, "#A12");
 467                         Assert.AreEqual (false, mc.IsBinaryData, "#A12-1");
 468
 469                         mc = t.GetColumn ("ObjectArray_Column");
 470                         Assert.IsNotNull (mc, "#A13");
 471                         Assert.AreEqual (false, mc.IsBinaryData, "#A13-1");
 472
 473                         mc = t.GetColumn ("StringList_Column");
 474                         Assert.IsNotNull (mc, "#A14");
 475                         Assert.AreEqual (false, mc.IsBinaryData, "#A14-1");
 476
 477                         mc = t.GetColumn ("Dictionary_Column");
 478                         Assert.IsNotNull (mc, "#A15");
 479                         Assert.AreEqual (false, mc.IsBinaryData, "#A15-1");
 480
 481                         mc = t.GetColumn ("ICollection_Column");
 482                         Assert.IsNotNull (mc, "#A16");
 483                         Assert.AreEqual (false, mc.IsBinaryData, "#A16-1");
 484
 485                         mc = t.GetColumn ("IEnumerable_Column");
 486                         Assert.IsNotNull (mc, "#A17");
 487                         Assert.AreEqual (false, mc.IsBinaryData, "#A17-1");
 488
 489                         mc = t.GetColumn ("ICollectionByte_Column");
 490                         Assert.IsNotNull (mc, "#A18");
 491                         Assert.AreEqual (false, mc.IsBinaryData, "#A18-1");
 492
 493                         mc = t.GetColumn ("IEnumerableByte_Column");
 494                         Assert.IsNotNull (mc, "#A19");
 495                         Assert.AreEqual (false, mc.IsBinaryData, "#A19-1");
 496
 497                         mc = t.GetColumn ("ByteMultiArray_Column");
 498                         Assert.IsNotNull (mc, "#A20");
 499                         Assert.AreEqual (false, mc.IsBinaryData, "#A20-1");
 500
 501                         mc = t.GetColumn ("BoolArray_Column");
 502                         Assert.IsNotNull (mc, "#A21");
 503                         Assert.AreEqual (false, mc.IsBinaryData, "#A21-1");
 504                 }
 505
 506                 [Test]
 507                 public void IsCustomProperty ()
 508                 {
 509                         MetaModel m = Utils.CommonInitialize ();
 510
 511                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 512                         MetaColumn mc = t.GetColumn ("CustomPropertyColumn1");
 513                         Assert.IsNotNull (mc, "#A1");
 514                         Assert.AreEqual (true, mc.IsCustomProperty, "#A1-1");
 515                         Assert.AreEqual (mc.Provider.IsCustomProperty, mc.IsCustomProperty, "#A1-2");
 516
 517                         mc = t.GetColumn ("Column1");
 518                         Assert.IsNotNull (mc, "#B1");
 519                         Assert.AreEqual (false, mc.IsCustomProperty, "#B1-1");
 520                         Assert.AreEqual (mc.Provider.IsCustomProperty, mc.IsCustomProperty, "#B1-2");
 521                 }
 522
 523                 [Test]
 524                 public void IsFloatingPoint ()
 525                 {
 526                         MetaModel m = Utils.CommonInitialize ();
 527
 528                         MetaTable t = m.Tables[TestDataContext.TableBazDataTypeDefaultTypes];
 529                         MetaColumn mc = t.GetColumn ("Int_Column");
 530                         Assert.IsNotNull (mc, "#A1");
 531                         Assert.AreEqual (false, mc.IsFloatingPoint, "#A1-1");
 532
 533                         mc = t.GetColumn ("Long_Column");
 534                         Assert.IsNotNull (mc, "#A2");
 535                         Assert.AreEqual (false, mc.IsFloatingPoint, "#A2-1");
 536
 537                         mc = t.GetColumn ("Bool_Column");
 538                         Assert.IsNotNull (mc, "#A3");
 539                         Assert.AreEqual (false, mc.IsFloatingPoint, "#A3-1");
 540
 541                         mc = t.GetColumn ("Single_Column");
 542                         Assert.IsNotNull (mc, "#A4");
 543                         Assert.AreEqual (true, mc.IsFloatingPoint, "#A4-1");
 544
 545                         mc = t.GetColumn ("Float_Column");
 546                         Assert.IsNotNull (mc, "#A5");
 547                         Assert.AreEqual (true, mc.IsFloatingPoint, "#A5-1");
 548
 549                         mc = t.GetColumn ("Double_Column");
 550                         Assert.IsNotNull (mc, "#A6");
 551                         Assert.AreEqual (true, mc.IsFloatingPoint, "#A6-1");
 552
 553                         mc = t.GetColumn ("Decimal_Column");
 554                         Assert.IsNotNull (mc, "#A7");
 555                         Assert.AreEqual (true, mc.IsFloatingPoint, "#A7-1");
 556                 }
 557
 558                 [Test]
 559                 public void IsForeignKeyComponent ()
 560                 {
 561                         MetaModel m = Utils.CommonInitialize ();
 562
 563                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 564                         MetaColumn mc = t.GetColumn ("Column1");
 565                         Assert.IsNotNull (mc, "#A1");
 566                         Assert.AreEqual (false, mc.IsForeignKeyComponent, "#A1-1");
 567
 568                         t = m.Tables[TestDataContext.TableAssociatedFoo];
 569                         mc = t.GetColumn ("ForeignKeyColumn1");
 570                         Assert.IsNotNull (mc, "#B1");
 571                         Assert.AreEqual (true, mc.IsForeignKeyComponent, "#B1-1");
 572
 573                         mc = t.GetColumn ("PrimaryKeyColumn1");
 574                         Assert.IsNotNull (mc, "#B2");
 575                         Assert.AreEqual (true, mc.IsForeignKeyComponent, "#B2-1");
 576
 577                         mc = t.GetColumn ("Column1");
 578                         Assert.IsNotNull (mc, "#B3");
 579                         Assert.AreEqual (false, mc.IsForeignKeyComponent, "#B3-1");
 580                 }
 581
 582                 [Test]
 583                 public void IsGenerated ()
 584                 {
 585                         MetaModel m = Utils.CommonInitialize ();
 586
 587                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 588                         MetaColumn mc = t.GetColumn ("Column1");
 589                         Assert.IsNotNull (mc, "#A1");
 590                         Assert.AreEqual (false, mc.IsGenerated, "#A1-1");
 591
 592                         mc = t.GetColumn ("GeneratedColumn1");
 593                         Assert.IsNotNull (mc, "#A2");
 594                         Assert.AreEqual (true, mc.IsGenerated, "#A2-1");
 595                 }
 596
 597                 [Test]
 598                 public void IsInteger ()
 599                 {
 600                         MetaModel m = Utils.CommonInitialize ();
 601
 602                         MetaTable t = m.Tables[TestDataContext.TableBazDataTypeDefaultTypes];
 603                         MetaColumn mc = t.GetColumn ("Char_Column");
 604                         Assert.IsNotNull (mc, "#A1");
 605                         Assert.AreEqual (false, mc.IsInteger, "#A1-1");
 606
 607                         mc = t.GetColumn ("Byte_Column");
 608                         Assert.IsNotNull (mc, "#A2");
 609                         Assert.AreEqual (true, mc.IsInteger, "#A2-1");
 610
 611                         mc = t.GetColumn ("SByte_Column");
 612                         Assert.IsNotNull (mc, "#A3");
 613                         Assert.AreEqual (false, mc.IsInteger, "#A3-1");
 614
 615                         mc = t.GetColumn ("SByte_Column");
 616                         Assert.IsNotNull (mc, "#A3");
 617                         Assert.AreEqual (false, mc.IsInteger, "#A3-1");
 618
 619                         mc = t.GetColumn ("Int_Column");
 620                         Assert.IsNotNull (mc, "#A4");
 621                         Assert.AreEqual (true, mc.IsInteger, "#A4-1");
 622
 623                         mc = t.GetColumn ("UInt_Column");
 624                         Assert.IsNotNull (mc, "#A5");
 625                         Assert.AreEqual (false, mc.IsInteger, "#A5-1");
 626
 627                         mc = t.GetColumn ("Long_Column");
 628                         Assert.IsNotNull (mc, "#A6");
 629                         Assert.AreEqual (true, mc.IsInteger, "#A6-1");
 630
 631                         mc = t.GetColumn ("ULong_Column");
 632                         Assert.IsNotNull (mc, "#A7");
 633                         Assert.AreEqual (false, mc.IsInteger, "#A7-1");
 634
 635                         mc = t.GetColumn ("Short_Column");
 636                         Assert.IsNotNull (mc, "#A8");
 637                         Assert.AreEqual (true, mc.IsInteger, "#A8-1");
 638
 639                         mc = t.GetColumn ("UShort_Column");
 640                         Assert.IsNotNull (mc, "#A9");
 641                         Assert.AreEqual (false, mc.IsInteger, "#A9-1");
 642
 643                         mc = t.GetColumn ("DateTime_Column");
 644                         Assert.IsNotNull (mc, "#A10");
 645                         Assert.AreEqual (false, mc.IsInteger, "#A10-1");
 646
 647                         mc = t.GetColumn ("Float_Column");
 648                         Assert.IsNotNull (mc, "#A11");
 649                         Assert.AreEqual (false, mc.IsInteger, "#A11-1");
 650                 }
 651
 652                 [Test]
 653                 public void IsLongString ()
 654                 {
 655                         MetaModel m = Utils.CommonInitialize ();
 656
 657                         MetaTable t = m.Tables[TestDataContext.TableBazDataTypeDefaultTypes];
 658                         MetaColumn mc = t.GetColumn ("String_Column");
 659                         Assert.IsNotNull (mc, "#A1");
 660                         Assert.AreEqual (true, mc.IsString, "#A1-1");
 661                         Assert.AreEqual (false, mc.IsLongString, "#A1-2");
 662                         Assert.AreEqual (0, mc.MaxLength, "#A1-3");
 663
 664                         mc = t.GetColumn ("MaximumLength_Column1");
 665                         Assert.IsNotNull (mc, "#B1");
 666                         Assert.AreEqual (true, mc.IsString, "#B1-1");
 667                         Assert.AreEqual (true, mc.IsLongString, "#B1-2");
 668                         Assert.AreEqual (Int32.MaxValue, mc.MaxLength, "#B1-3");
 669
 670                         // It appears .NET allows for negative maximum lengths...
 671                         mc = t.GetColumn ("MaximumLength_Column2");
 672                         Assert.IsNotNull (mc, "#C1");
 673                         Assert.AreEqual (true, mc.IsString, "#C1-1");
 674                         Assert.AreEqual (false, mc.IsLongString, "#C1-2");
 675                         Assert.AreEqual (Int32.MinValue, mc.MaxLength, "#C1-3");
 676
 677                         // This is the highest length at which string is considered to be short
 678                         mc = t.GetColumn ("MaximumLength_Column3");
 679                         Assert.IsNotNull (mc, "#D1");
 680                         Assert.AreEqual (true, mc.IsString, "#D1-1");
 681                         Assert.AreEqual (false, mc.IsLongString, "#D1-2");
 682                         Assert.AreEqual ((Int32.MaxValue / 2) - 5, mc.MaxLength, "#D1-3");
 683
 684                         // This is the lowest length at which string is considered to be short
 685                         mc = t.GetColumn ("MaximumLength_Column4");
 686                         Assert.IsNotNull (mc, "#E1");
 687                         Assert.AreEqual (true, mc.IsString, "#E1-1");
 688                         Assert.AreEqual (true, mc.IsLongString, "#E1-2");
 689                         Assert.AreEqual ((Int32.MaxValue / 2) - 4, mc.MaxLength, "#E1-3");
 690                 }
 691
 692                 [Test]
 693                 public void IsPrimaryKey ()
 694                 {
 695                         MetaModel m = Utils.CommonInitialize ();
 696
 697                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 698                         MetaColumn mc = t.GetColumn ("Column1");
 699                         Assert.IsNotNull (mc, "#A1");
 700                         Assert.AreEqual (false, mc.IsPrimaryKey, "#A1-1");
 701                         Assert.AreEqual (mc.Provider.IsPrimaryKey, mc.IsPrimaryKey, "#A1-2");
 702
 703                         mc = t.GetColumn ("PrimaryKeyColumn1");
 704                         Assert.IsNotNull (mc, "#A2");
 705                         Assert.AreEqual (true, mc.IsPrimaryKey, "#A2-1");
 706                         Assert.AreEqual (mc.Provider.IsPrimaryKey, mc.IsPrimaryKey, "#A2-2");
 707
 708                         t = m.Tables[TestDataContext.TableAssociatedFoo];
 709                         mc = t.GetColumn ("ForeignKeyColumn1");
 710                         Assert.IsNotNull (mc, "#B1");
 711                         Assert.AreEqual (false, mc.IsPrimaryKey, "#B1-1");
 712                         Assert.AreEqual (mc.Provider.IsPrimaryKey, mc.IsPrimaryKey, "#B1-2");
 713
 714                         mc = t.GetColumn ("PrimaryKeyColumn1");
 715                         Assert.IsNotNull (mc, "#B2");
 716                         Assert.AreEqual (true, mc.IsPrimaryKey, "#B2-1");
 717                         Assert.AreEqual (mc.Provider.IsPrimaryKey, mc.IsPrimaryKey, "#B2-2");
 718                 }
 719
 720                 [Test]
 721                 public void IsReadOnly ()
 722                 {
 723                         MetaModel m = Utils.CommonInitialize ();
 724
 725                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 726                         MetaColumn mc = t.GetColumn ("ReadOnlyColumn");
 727                         Assert.IsNotNull (mc, "#A1");
 728                         Assert.AreEqual (true, mc.IsReadOnly, "#A1-1");
 729
 730                         // Apparently it value passed to ReadOnlyAttribute's constructor doesn't matter.
 731                         // The only presence of it marks the column as read-only
 732                         mc = t.GetColumn ("ReadWriteColumn");
 733                         Assert.IsNotNull (mc, "#B1");
 734                         Assert.AreEqual (true, mc.IsReadOnly, "#B1-1");
 735
 736                         mc = t.GetColumn ("Column1");
 737                         Assert.IsNotNull (mc, "#C1");
 738                         Assert.AreEqual (false, mc.IsReadOnly, "#C1-1");
 739                 }
 740
 741                 [Test]
 742                 public void IsRequired ()
 743                 {
 744                         MetaModel m = Utils.CommonInitialize ();
 745
 746                         MetaTable t = m.Tables[TestDataContext.TableFooWithMetadataType];
 747                         MetaColumn mc = t.GetColumn ("Column1");
 748                         Assert.IsNotNull (mc, "#A1");
 749                         Assert.IsTrue (mc.IsRequired, "#A1-1");
 750                         Assert.AreEqual (1, mc.Attributes.OfType<RequiredAttribute> ().Count (), "#A1-2");
 751
 752                         mc = t.GetColumn ("Column5");
 753                         Assert.IsNotNull (mc, "#B1");
 754                         Assert.IsTrue (mc.IsRequired, "#B1-1");
 755                         Assert.AreEqual (1, mc.Attributes.OfType<RequiredAttribute> ().Count (), "#B1-2");
 756
 757                         // This one is made nullable by the test column provider
 758                         mc = t.GetColumn ("Column6");
 759                         Assert.IsNotNull (mc, "#C1");
 760                         Assert.IsFalse (mc.IsRequired, "#C1-1");
 761                         Assert.AreEqual (0, mc.Attributes.OfType<RequiredAttribute> ().Count (), "#C1-2");
 762
 763                         mc = t.GetColumn ("Column7");
 764                         Assert.IsNotNull (mc, "#D1");
 765                         Assert.IsTrue (mc.IsRequired, "#D1-1");
 766                         Assert.AreEqual (1, mc.Attributes.OfType<RequiredAttribute> ().Count (), "#D1-2");
 767
 768                         mc = t.GetColumn ("Column2");
 769                         Assert.IsNotNull (mc, "#E1");
 770                         Assert.IsTrue (mc.IsRequired, "#F1-1");
 771                         Assert.AreEqual (1, mc.Attributes.OfType<RequiredAttribute> ().Count (), "#E1-2");
 772                 }
 773
 774                 [Test]
 775                 public void IsString ()
 776                 {
 777                         MetaModel m = Utils.CommonInitialize ();
 778
 779                         MetaTable t = m.Tables[TestDataContext.TableBazDataTypeDefaultTypes];
 780                         MetaColumn mc = t.GetColumn ("Char_Column");
 781                         Assert.IsNotNull (mc, "#A1");
 782                         Assert.AreEqual (false, mc.IsString, "#A1-1");
 783
 784                         mc = t.GetColumn ("Int_Column");
 785                         Assert.IsNotNull (mc, "#B1");
 786                         Assert.AreEqual (false, mc.IsString, "#B1-1");
 787
 788                         mc = t.GetColumn ("String_Column");
 789                         Assert.IsNotNull (mc, "#C1");
 790                         Assert.AreEqual (true, mc.IsString, "#C1-1");
 791                 }
 792
 793                 [Test]
 794                 public void MaxLength ()
 795                 {
 796                         MetaModel m = Utils.CommonInitialize ();
 797
 798                         MetaTable t = m.Tables[TestDataContext.TableBazDataTypeDefaultTypes];
 799                         MetaColumn mc = t.GetColumn ("Char_Column");
 800                         Assert.IsNotNull (mc, "#A1");
 801                         Assert.AreEqual (0, mc.MaxLength, "#A1-1");
 802
 803                         mc = t.GetColumn ("String_Column");
 804                         Assert.IsNotNull (mc, "#A2");
 805                         Assert.AreEqual (0, mc.MaxLength, "#A2-1");
 806
 807                         mc = t.GetColumn ("MaximumLength_Column1");
 808                         Assert.IsNotNull (mc, "#A3");
 809                         Assert.AreEqual (Int32.MaxValue, mc.MaxLength, "#A3-1");
 810
 811                         mc = t.GetColumn ("MaximumLength_Column2");
 812                         Assert.IsNotNull (mc, "#A4");
 813                         Assert.AreEqual (Int32.MinValue, mc.MaxLength, "#A4-1");
 814
 815                         mc = t.GetColumn ("MaximumLength_Column3");
 816                         Assert.IsNotNull (mc, "#A5");
 817                         Assert.AreEqual ((Int32.MaxValue / 2) - 5, mc.MaxLength, "#A5-1");
 818
 819                         mc = t.GetColumn ("MaximumLength_Column4");
 820                         Assert.IsNotNull (mc, "#A6");
 821                         Assert.AreEqual ((Int32.MaxValue / 2) - 4, mc.MaxLength, "#A6-1");
 822
 823                         mc = t.GetColumn ("MaximumLength_Column5");
 824                         Assert.IsNotNull (mc, "#A7");
 825                         Assert.AreEqual (255, mc.MaxLength, "#A7-1");
 826                         Assert.AreEqual (512, mc.Provider.MaxLength, "#A7-2");
 827                         Assert.IsTrue (mc.MaxLength != mc.Provider.MaxLength, "#A7-3");
 828                 }
 829
 830                 [Test]
 831                 public void Model ()
 832                 {
 833                         MetaModel m = Utils.CommonInitialize ();
 834
 835                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 836                         MetaColumn mc = t.GetColumn ("Column1");
 837                         Assert.IsNotNull (mc, "#A1");
 838                         Assert.IsTrue (mc.Model == m, "#A2");
 839                 }
 840
 841                 [Test]
 842                 public void Name ()
 843                 {
 844                         MetaModel m = Utils.CommonInitialize ();
 845
 846                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 847                         MetaColumn mc = t.GetColumn ("Column1");
 848                         Assert.IsNotNull (mc, "#A1");
 849                         Assert.AreEqual ("Column1", mc.Name, "#A2");
 850                 }
 851
 852                 [Test]
 853                 public void NullDisplayText ()
 854                 {
 855                         MetaModel m = Utils.CommonInitialize ();
 856
 857                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 858                         MetaColumn mc = t.GetColumn ("Column1");
 859                         Assert.IsNotNull (mc, "#A1");
 860                         Assert.AreEqual (String.Empty, mc.NullDisplayText, "#A1-1");
 861
 862                         mc = t.GetColumn ("NullDisplayTextColumn");
 863                         Assert.IsNotNull (mc, "#A2");
 864                         Assert.AreEqual ("Text", mc.NullDisplayText, "#A2-1");
 865                 }
 866
 867                 [Test]
 868                 public void Provider ()
 869                 {
 870                         MetaModel m = Utils.CommonInitialize ();
 871
 872                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 873                         MetaColumn mc = t.GetColumn ("Column1");
 874                         Assert.IsNotNull (mc, "#A1");
 875                         Assert.IsNotNull (mc.Provider, "#A2");
 876                 }
 877
 878                 [Test]
 879                 public void RequiredErrorMessage ()
 880                 {
 881                         MetaModel m = Utils.CommonInitialize ();
 882
 883                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 884                         MetaColumn mc = t.GetColumn ("Column1");
 885                         Assert.IsNotNull (mc, "#A1");
 886 //                      Assert.IsFalse (String.IsNullOrEmpty (mc.RequiredErrorMessage), "#A2");
 887
 888                         mc = t.GetColumn ("ErrorMessageColumn1");
 889                         Assert.IsNotNull (mc, "#B1");
 890                         Assert.IsFalse (String.IsNullOrEmpty (mc.RequiredErrorMessage), "#B2");
 891                         Assert.AreEqual ("Custom error message", mc.RequiredErrorMessage, "#B3");
 892
 893                         mc = t.GetColumn ("ErrorMessageColumn2");
 894                         Assert.IsNotNull (mc, "#C1");
 895                         Assert.IsFalse (String.IsNullOrEmpty (mc.RequiredErrorMessage), "#C2");
 896
 897                         t = m.Tables[TestDataContext.TableFooWithMetadataType];
 898                         mc = t.GetColumn ("Column6");
 899                         Assert.IsNotNull (mc, "#D1");
 900                         Assert.IsFalse (mc.IsRequired, "#D1-1");
 901                         Assert.AreEqual (0, mc.Attributes.OfType<RequiredAttribute> ().Count (), "#D1-2");
 902                         Assert.AreEqual (String.Empty, mc.RequiredErrorMessage, "#D1-3");
 903                 }
 904
 905                 [Test]
 906                 public void Scaffold ()
 907                 {
 908                         //
 909                         // ScaffoldAllTables=true is in effect for this model
 910                         //
 911                         MetaModel m = Utils.CommonInitialize ();
 912
 913                         MetaTable t = m.Tables[TestDataContext.TableBazColumnAttributes];
 914                         MetaColumn mc = t.GetColumn ("NoScaffoldColumn");
 915                         Assert.IsNotNull (mc, "#1");
 916                         Assert.AreEqual (false, mc.Scaffold, "#1-1");
 917
 918                         mc = t.GetColumn ("ScaffoldAttributeColumn");
 919                         Assert.IsNotNull (mc, "#2");
 920                         Assert.AreEqual (true, mc.Scaffold, "#2-1");
 921
 922                         mc = t.GetColumn ("ColumnNoAttributes");
 923                         Assert.IsNotNull (mc, "#3");
 924                         Assert.AreEqual (true, mc.Scaffold, "#3-1");
 925
 926                         // No attribute cases
 927                         mc = t.GetColumn ("UIHintColumn");
 928                         Assert.IsNotNull (mc, "#4");
 929                         Assert.AreEqual (true, mc.Scaffold, "#4-1");
 930
 931                         t = m.Tables[TestDataContext.TableFooNoScaffold];
 932                         mc = t.GetColumn ("Column1");
 933                         Assert.IsNotNull (mc, "#5");
 934                         Assert.AreEqual (true, mc.Scaffold, "#5-1");
 935
 936                         t = m.Tables[TestDataContext.TableBaz];
 937                         mc = t.GetColumn ("GeneratedColumn1");
 938                         Assert.IsNotNull (mc, "#6");
 939                         Assert.AreEqual (false, mc.Scaffold, "#6-1");
 940
 941                         mc = t.GetColumn ("GeneratedColumn2");
 942                         Assert.IsNotNull (mc, "#7");
 943                         Assert.AreEqual (true, mc.Scaffold, "#7-1");
 944
 945                         mc = t.GetColumn ("CustomPropertyColumn1");
 946                         Assert.IsNotNull (mc, "#8");
 947                         Assert.AreEqual (false, mc.Scaffold, "#8-1");
 948
 949                         mc = t.GetColumn ("CustomPropertyColumn2");
 950                         Assert.IsNotNull (mc, "#9");
 951                         Assert.AreEqual (true, mc.Scaffold, "#9-1");
 952
 953                         t = m.Tables[TestDataContext.TableAssociatedFoo];
 954                         mc = t.GetColumn ("ForeignKeyColumn1");
 955                         Assert.IsNotNull (mc, "#10");
 956                         Assert.AreEqual (true, mc.IsForeignKeyComponent, "#10-1");
 957                         Assert.AreEqual (true, mc.Scaffold, "#11-2");
 958
 959                         m = MetaModel.GetModel (dynamicModelProviderNoScaffold.ContextType);
 960                         t = m.Tables[TestDataContext2.TableFooBarNoScaffold];
 961                         mc = t.GetColumn ("Column1");
 962                         Assert.IsNotNull (mc, "#12");
 963                         Assert.AreEqual (true, mc.Scaffold, "#12-1");
 964
 965                         mc = t.GetColumn ("CustomPropertyColumn1");
 966                         Assert.IsNotNull (mc, "#13");
 967                         Assert.AreEqual (false, mc.Scaffold, "#13-1");
 968
 969                         mc = t.GetColumn ("CustomPropertyColumn2");
 970                         Assert.IsNotNull (mc, "#14");
 971                         Assert.AreEqual (true, mc.Scaffold, "#14-1");
 972
 973                         mc = t.GetColumn ("GeneratedColumn1");
 974                         Assert.IsNotNull (mc, "#15");
 975                         Assert.AreEqual (false, mc.Scaffold, "#15-1");
 976
 977                         mc = t.GetColumn ("GeneratedColumn2");
 978                         Assert.IsNotNull (mc, "#16");
 979                         Assert.AreEqual (true, mc.Scaffold, "#16-1");
 980
 981                         mc = t.GetColumn ("ForeignKeyColumn1");
 982                         Assert.IsNotNull (mc, "#17");
 983                         Assert.AreEqual (true, mc.IsForeignKeyComponent, "#17-1");
 984                         Assert.AreEqual (true, mc.Scaffold, "#17-2");
 985                 }
 986
 987                 [Test]
 988                 public void SortExpression ()
 989                 {
 990                         MetaModel m = Utils.CommonInitialize ();
 991
 992                         MetaTable t = m.Tables[TestDataContext.TableBaz];
 993                         MetaColumn mc = t.GetColumn ("Column1");
 994                         Assert.IsNotNull (mc, "#A1");
 995                         Assert.AreEqual (false, mc.Provider.IsSortable, "#A1-1");
 996                         Assert.AreEqual (String.Empty, mc.SortExpression, "#A1-2");
 997
 998                         mc = t.GetColumn ("SortableColumn1");
 999                         Assert.IsNotNull (mc, "#B1");
1000                         Assert.AreEqual (true, mc.Provider.IsSortable, "#B1-1");
1001                         Assert.AreEqual ("SortableColumn1", mc.SortExpression, "#B1-2");
1002                 }
1003
1004                 [Test]
1005                 public void Table ()
1006                 {
1007                         MetaModel m = Utils.CommonInitialize ();
1008
1009                         MetaTable t = m.Tables[TestDataContext.TableBaz];
1010                         MetaColumn mc = t.GetColumn ("Column1");
1011                         Assert.IsNotNull (mc, "#A1");
1012                         Assert.IsTrue (mc.Table == t, "#A2");
1013                 }
1014
1015                 [Test]
1016                 public void TypeCodeTest ()
1017                 {
1018                         MetaModel m = Utils.CommonInitialize ();
1019
1020                         MetaTable t = m.Tables[TestDataContext.TableBazDataTypeDefaultTypes];
1021                         MetaColumn mc = t.GetColumn ("Char_Column");
1022                         Assert.IsNotNull (mc, "#A1");
1023                         Assert.AreEqual (typeof (char), mc.ColumnType, "#A1-1");
1024                         Assert.AreEqual (TypeCode.Object, mc.TypeCode, "#A1-2");
1025
1026                         mc = t.GetColumn ("String_Column");
1027                         Assert.IsNotNull (mc, "#B1");
1028                         Assert.AreEqual (typeof (string), mc.ColumnType, "#B1-1");
1029                         Assert.AreEqual (TypeCode.String, mc.TypeCode, "#B1-2");
1030
1031                         mc = t.GetColumn ("Byte_Column");
1032                         Assert.IsNotNull (mc, "#C1");
1033                         Assert.AreEqual (typeof (byte), mc.ColumnType, "#C1-1");
1034                         Assert.AreEqual (TypeCode.Byte, mc.TypeCode, "#C1-2");
1035
1036                         mc = t.GetColumn ("SByte_Column");
1037                         Assert.IsNotNull (mc, "#D1");
1038                         Assert.AreEqual (typeof (sbyte), mc.ColumnType, "#d1-1");
1039                         Assert.AreEqual (TypeCode.Object, mc.TypeCode, "#D1-2");
1040
1041                         mc = t.GetColumn ("Int_Column");
1042                         Assert.IsNotNull (mc, "#E1");
1043                         Assert.AreEqual (typeof (int), mc.ColumnType, "#E1-1");
1044                         Assert.AreEqual (TypeCode.Int32, mc.TypeCode, "#E1-2");
1045
1046                         mc = t.GetColumn ("UInt_Column");
1047                         Assert.IsNotNull (mc, "#F1");
1048                         Assert.AreEqual (typeof (uint), mc.ColumnType, "#F1-1");
1049                         Assert.AreEqual (TypeCode.Object, mc.TypeCode, "#F1-2");
1050
1051                         mc = t.GetColumn ("Long_Column");
1052                         Assert.IsNotNull (mc, "#G1");
1053                         Assert.AreEqual (typeof (long), mc.ColumnType, "#G1-1");
1054                         Assert.AreEqual (TypeCode.Int64, mc.TypeCode, "#G1-2");
1055
1056                         mc = t.GetColumn ("Float_Column");
1057                         Assert.IsNotNull (mc, "#H1");
1058                         Assert.AreEqual (typeof (float), mc.ColumnType, "#H1-1");
1059                         Assert.AreEqual (TypeCode.Single, mc.TypeCode, "#H1-2");
1060
1061                         mc = t.GetColumn ("Double_Column");
1062                         Assert.IsNotNull (mc, "#I1");
1063                         Assert.AreEqual (typeof (double), mc.ColumnType, "#I1-1");
1064                         Assert.AreEqual (TypeCode.Double, mc.TypeCode, "#I1-2");
1065
1066                         mc = t.GetColumn ("Decimal_Column");
1067                         Assert.IsNotNull (mc, "#J1");
1068                         Assert.AreEqual (typeof (decimal), mc.ColumnType, "#J1-1");
1069                         Assert.AreEqual (TypeCode.Decimal, mc.TypeCode, "#J1-2");
1070
1071                         mc = t.GetColumn ("StringArray_Column");
1072                         Assert.IsNotNull (mc, "#K1");
1073                         Assert.AreEqual (typeof (string[]), mc.ColumnType, "#K1-1");
1074                         Assert.AreEqual (TypeCode.Object, mc.TypeCode, "#K1-2");
1075                 }
1076
1077                 [Test]
1078                 public void UIHint ()
1079                 {
1080                         MetaModel m = Utils.CommonInitialize ();
1081
1082                         MetaTable t = m.Tables[TestDataContext.TableBaz];
1083                         MetaColumn mc = t.GetColumn ("CustomPropertyColumn1");
1084                         Assert.IsNotNull (mc, "#A1");
1085                         Assert.AreEqual (null, mc.UIHint, "#A2");
1086
1087                         mc = t.GetColumn ("Column1");
1088                         Assert.IsNotNull (mc, "#B1");
1089                         Assert.AreEqual (null, mc.UIHint, "#B2");
1090
1091                         mc = t.GetColumn ("CustomPropertyColumn2");
1092                         Assert.IsNotNull (mc, "#C1");
1093                         Assert.AreEqual ("UI Hint", mc.UIHint, "#C2");
1094
1095                         mc = t.GetColumn ("EmptyHintColumn");
1096                         Assert.IsNotNull (mc, "#D1");
1097                         Assert.AreEqual (String.Empty, mc.UIHint, "#D2");
1098                 }
1099         }
1100 }