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