Components/DictionaryAdapter/Castle.Components.DictionaryAdapter.Tests/DictionaryAdapterFactoryTestCase.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15
  16 namespace Castle.Components.DictionaryAdapter.Tests
  17 {
  18         using System;
  19         using System.Collections;
  20         using System.Collections.Generic;
  21         using System.ComponentModel;
  22         using System.Globalization;
  23         using NUnit.Framework;
  24
  25         [TestFixture]
  26         public class DictionaryAdapterFactoryTestCase
  27         {
  28                 private IDictionary dictionary;
  29                 private DictionaryAdapterFactory factory;
  30
  31                 [SetUp]
  32                 public void SetUp()
  33                 {
  34                         dictionary = new Hashtable();
  35                         factory = new DictionaryAdapterFactory();
  36                 }
  37
  38                 [Test]
  39                 public void CreateAdapter_NoPrefixPropertiesOnly_WorksFine()
  40                 {
  41                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
  42                         Assert.IsNotNull(person);
  43                 }
  44
  45                 [Test, ExpectedException(typeof(TypeLoadException))]
  46                 public void CreateAdapter_NoPrefixWithMethod_ThrowsException()
  47                 {
  48                         factory.GetAdapter<IPersonWithMethod>(dictionary);
  49                 }
  50
  51                 [Test]
  52                 public void CreateAdapter_PrefixPropertiesOnly_WorksFine()
  53                 {
  54                         IPerson person = factory.GetAdapter<IPersonWithPrefix>(dictionary);
  55                         Assert.IsNotNull(person);
  56                 }
  57
  58                 [Test]
  59                 public void UpdateAdapter_NoPrefix_UpdatesDictionary()
  60                 {
  61                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
  62                         person.Name = "Craig";
  63                         person.Age = 37;
  64                         person.DOB = new DateTime(1970, 7, 19);
  65                         person.Friends = new List<IPerson>(); // I need some friends
  66
  67                         Assert.AreEqual("Craig", dictionary["Name"]);
  68                         Assert.AreEqual(37, dictionary["Age"]);
  69                         Assert.AreEqual(new DateTime(1970, 7, 19), dictionary["DOB"]);
  70                         Assert.AreEqual(0, ((IList<IPerson>) dictionary["Friends"]).Count);
  71                 }
  72
  73                 [Test]
  74                 public void UpdateAdapter_Prefix_UpdatesDictionary()
  75                 {
  76                         IPerson person = factory.GetAdapter<IPersonWithPrefix>(dictionary);
  77                         person.Name = "Craig";
  78                         person.Age = 37;
  79                         person.DOB = new DateTime(1970, 7, 19);
  80                         person.Friends = new List<IPerson>();
  81                         Assert.AreEqual("Craig", dictionary["Name"]);
  82                         Assert.AreEqual(37, dictionary["Age"]);
  83                         Assert.AreEqual(new DateTime(1970, 7, 19), dictionary["DOB"]);
  84                         Assert.AreEqual(0, ((IList<IPerson>) dictionary["Friends"]).Count);
  85                 }
  86
  87                 [Test]
  88                 public void UpdateAdapterAndRead_NoPrefix_Matches()
  89                 {
  90                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
  91                         person.Name = "Craig";
  92                         person.Age = 37;
  93                         person.DOB = new DateTime(1970, 7, 19);
  94                         person.Friends = new List<IPerson>();
  95
  96                         Assert.AreEqual("Craig", person.Name);
  97                         Assert.AreEqual(37, person.Age);
  98                         Assert.AreEqual(new DateTime(1970, 7, 19), person.DOB);
  99                         Assert.AreEqual(0, person.Friends.Count);
 100                 }
 101
 102                 [Test]
 103                 public void UpdateAdapterAndRead_Prefix_Matches()
 104                 {
 105                         IPerson person = factory.GetAdapter<IPersonWithPrefix>(dictionary);
 106                         person.Name = "Craig";
 107                         person.Age = 37;
 108                         person.DOB = new DateTime(1970, 7, 19);
 109                         person.Friends = new List<IPerson>();
 110
 111                         Assert.AreEqual("Craig", person.Name);
 112                         Assert.AreEqual(37, person.Age);
 113                         Assert.AreEqual(new DateTime(1970, 7, 19), person.DOB);
 114                         Assert.AreEqual(0, person.Friends.Count);
 115                 }
 116
 117                 [Test]
 118                 public void UpdateAdapterAndRead_PrefixOverride_Matches()
 119                 {
 120                         IPerson person = factory.GetAdapter<IPersonWithPrefixOverride>(dictionary);
 121                         person.Name = "Craig";
 122
 123                         Assert.AreEqual("Craig", dictionary["Name"]);
 124                 }
 125
 126                 [Test]
 127                 public void ReadAdapter_NoPrefixUnitialized_ReturnsDefaults()
 128                 {
 129                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 130
 131                         Assert.AreEqual(default(string), person.Name);
 132                         Assert.AreEqual(default(int), person.Age);
 133                         Assert.AreEqual(default(DateTime), person.DOB);
 134                         Assert.AreEqual(default(IList<IPerson>), person.Friends);
 135                 }
 136
 137                 [Test]
 138                 public void ReadAdapter_PrefixUnitialized_ReturnsDefaults()
 139                 {
 140                         IPerson person = factory.GetAdapter<IPersonWithPrefix>(dictionary);
 141
 142                         Assert.AreEqual(default(string), person.Name);
 143                         Assert.AreEqual(default(int), person.Age);
 144                         Assert.AreEqual(default(DateTime), person.DOB);
 145                         Assert.AreEqual(default(IList<IPerson>), person.Friends);
 146                 }
 147
 148                 [Test]
 149                 public void UpdateAdapterAndRead_WithSeveralDifferentOverridesWithDifferentPrefixes_DictionaryKeysHaveCorrectPrefixes()
 150                 {
 151                         IPersonWithDeniedInheritancePrefix person = factory.GetAdapter<IPersonWithDeniedInheritancePrefix>(dictionary);
 152
 153                         string name = "Ming The Merciless";
 154                         int numberOfFeet = 2;
 155                         string hairColour = "Muddy Golden Labrador";
 156                         string eyeColour = "The Colour Of Broken Dreams";
 157                         int numberOfHeads = 1;
 158                         int numberOfFingers = 3;
 159
 160                         person.Name = name;
 161                         person.NumberOfFeet = numberOfFeet;
 162                         person.HairColour = hairColour;
 163                         person.EyeColour = eyeColour;
 164                         person.NumberOfHeads = numberOfHeads;
 165                         person.NumberOfFingers = numberOfFingers;
 166
 167                         string[] keys = new string[dictionary.Keys.Count];
 168                         dictionary.Keys.CopyTo(keys, 0);
 169
 170                         Assert.IsTrue(Array.Exists(keys, delegate(string key) { return key == "Name"; }));
 171                         Assert.IsTrue(Array.Exists(keys, delegate(string key) { return key == "NumberOfFeet"; }));
 172                         Assert.IsTrue(Array.Exists(keys, delegate(string key) { return key == "Person_HairColour"; }));
 173                         Assert.IsTrue(Array.Exists(keys, delegate(string key) { return key == "Person2_Eye__Colour"; }));
 174                         Assert.IsTrue(Array.Exists(keys, delegate(string key) { return key == "Person2_NumberOfHeads"; }));
 175                         Assert.IsTrue(Array.Exists(keys, delegate(string key) { return key == "NumberOfFingers"; }));
 176
 177                         Assert.AreEqual(name, person.Name);
 178                         Assert.AreEqual(numberOfFeet, person.NumberOfFeet);
 179                         Assert.AreEqual(hairColour, person.HairColour);
 180                         Assert.AreEqual(eyeColour, person.EyeColour);
 181                         Assert.AreEqual(numberOfHeads, person.NumberOfHeads);
 182                         Assert.AreEqual(numberOfFingers, person.NumberOfFingers);
 183                 }
 184
 185                 [Test]
 186                 public void CreateAdapter_WithSubstitionOnProperty_WorksFine()
 187                 {
 188                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 189                         person.First_Name = "Craig";
 190                         Assert.AreEqual("Craig", dictionary["First Name"]);
 191                 }
 192
 193                 [Test]
 194                 public void CreateAdapter_WithSubstitionOnInterface_WorksFine()
 195                 {
 196                         IPersonWithDeniedInheritancePrefix person = factory.GetAdapter<IPersonWithDeniedInheritancePrefix>(dictionary);
 197                         person.Max_Width = 22;
 198                         Assert.AreEqual(22, dictionary["Max Width"]);
 199                 }
 200
 201                 [Test]
 202                 public void CreateAdapter_WithComponent_WorksFine()
 203                 {
 204                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 205                         IAddress mailing = person.HomeAddress;
 206                         Assert.IsNotNull(mailing);
 207                 }
 208
 209                 [Test]
 210                 public void ReadAdapter_WithComponent_WorksFine()
 211                 {
 212                         dictionary["HomeAddress_Line1"] = "77 Lynwood Dr";
 213                         dictionary["HomeAddress_City"] = "Massapequa";
 214                         dictionary["HomeAddress_State"] = "NY";
 215                         dictionary["HomeAddress_ZipCode"] = "11288";
 216
 217                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 218                         IAddress home = person.HomeAddress;
 219
 220                         Assert.AreEqual(dictionary["HomeAddress_Line1"], home.Line1);
 221                         Assert.AreEqual(dictionary["HomeAddress_City"], home.City);
 222                         Assert.AreEqual(dictionary["HomeAddress_State"], home.State);
 223                         Assert.AreEqual(dictionary["HomeAddress_ZipCode"], home.ZipCode);
 224                 }
 225
 226                 [Test]
 227                 public void UpdateAdapter_WithComponent_WorksFine()
 228                 {
 229                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 230                         IAddress home = person.HomeAddress;
 231                         home.Line1 = "77 Lynwood Dr";
 232                         home.City = "Massapequa";
 233                         home.State = "NY";
 234                         home.ZipCode = "11288";
 235
 236                         Assert.AreEqual("77 Lynwood Dr", home.Line1);
 237                         Assert.AreEqual("Massapequa", home.City);
 238                         Assert.AreEqual("NY", home.State);
 239                         Assert.AreEqual("11288", home.ZipCode);
 240                 }
 241
 242                 [Test]
 243                 public void ReadAdapter_WithComponentOverrideNoPrefix_WorksFine()
 244                 {
 245                         dictionary["Line1"] = "139 Dartbrook";
 246                         dictionary["City"] = "Plano";
 247                         dictionary["State"] = "TX";
 248                         dictionary["ZipCode"] = "75062";
 249
 250                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 251                         IAddress work = person.WorkAddress;
 252
 253                         Assert.AreEqual(dictionary["Line1"], work.Line1);
 254                         Assert.AreEqual(dictionary["City"], work.City);
 255                         Assert.AreEqual(dictionary["State"], work.State);
 256                         Assert.AreEqual(dictionary["ZipCode"], work.ZipCode);
 257                 }
 258
 259                 [Test]
 260                 public void UpdateAdapter_WithComponentOverrideNoPrefix_WorksFine()
 261                 {
 262                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 263                         IAddress work = person.WorkAddress;
 264                         work.Line1 = "139 Dartbrook";
 265                         work.City = "Plano";
 266                         work.State = "TX";
 267                         work.ZipCode = "75062";
 268
 269                         Assert.AreEqual("139 Dartbrook", work.Line1);
 270                         Assert.AreEqual("Plano", work.City);
 271                         Assert.AreEqual("TX", work.State);
 272                         Assert.AreEqual("75062", work.ZipCode);
 273                 }
 274
 275                 [Test]
 276                 public void ReadAdapter_WithComponentOverridePrefix_WorksFine()
 277                 {
 278                         dictionary["Billing_Line1"] = "64 Country Rd";
 279                         dictionary["Billing_City"] = "Miami";
 280                         dictionary["Billing_State"] = "FL";
 281                         dictionary["Billing_ZipCode"] = "33101";
 282
 283                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 284                         IAddress billing = person.BillingAddress;
 285
 286                         Assert.AreEqual(dictionary["Billing_Line1"], billing.Line1);
 287                         Assert.AreEqual(dictionary["Billing_City"], billing.City);
 288                         Assert.AreEqual(dictionary["Billing_State"], billing.State);
 289                         Assert.AreEqual(dictionary["Billing_ZipCode"], billing.ZipCode);
 290                 }
 291
 292                 [Test]
 293                 public void UpdateAdapter_WithComponentOverridePrefix_WorksFine()
 294                 {
 295                         dictionary["Billing_Line1"] = "64 Country Rd";
 296                         dictionary["Billing_City"] = "Miami";
 297                         dictionary["Billing_State"] = "FL";
 298                         dictionary["Billing_ZipCode"] = "33101";
 299
 300                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 301                         IAddress billing = person.BillingAddress;
 302                         billing.Line1 = "64 Country Rd";
 303                         billing.City = "Miami";
 304                         billing.State = "FL";
 305                         billing.ZipCode = "33101";
 306                 }
 307
 308                 [Test]
 309                 public void CreateAdapter_WithNestedComponent_WorksFine()
 310                 {
 311                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 312                         IAddress mailing = person.HomeAddress;
 313                         Assert.IsNotNull(mailing.Phone);
 314                 }
 315
 316                 [Test]
 317                 public void ReadAdapter_WithNestedComponent_WorksFine()
 318                 {
 319                         dictionary["HomeAddress_Phone_Number"] = "212-353-1244";
 320                         dictionary["HomeAddress_Phone_Extension"] = "245";
 321
 322                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 323                         IPhone phone = person.HomeAddress.Phone;
 324
 325                         Assert.AreEqual(dictionary["HomeAddress_Phone_Number"], phone.Number);
 326                         Assert.AreEqual(dictionary["HomeAddress_Phone_Extension"], phone.Extension);
 327                 }
 328
 329                 [Test]
 330                 public void UpdateAdapter_WithNestedComponent_WorksFine()
 331                 {
 332                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 333                         IPhone phone = person.HomeAddress.Phone;
 334                         phone.Number = "212-353-1244";
 335                         phone.Extension = "245";
 336
 337                         Assert.AreEqual("212-353-1244", phone.Number);
 338                         Assert.AreEqual("245", phone.Extension);
 339                 }
 340
 341                 [Test]
 342                 public void ReadAdapter_WithNestedComponentOverrideNoPrefix_WorksFine()
 343                 {
 344                         dictionary["Number"] = "972-324-9821";
 345                         dictionary["Extension"] = "300";
 346
 347                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 348                         IPhone phone = person.WorkAddress.Mobile;
 349
 350                         Assert.AreEqual(dictionary["Number"], phone.Number);
 351                         Assert.AreEqual(dictionary["Extension"], phone.Extension);
 352                 }
 353
 354                 [Test]
 355                 public void UpdateAdapter_WithNestedComponentOverrideNoPrefix_WorksFine()
 356                 {
 357                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 358                         IPhone phone = person.HomeAddress.Mobile;
 359                         phone.Number = "972-324-9821";
 360                         phone.Extension = "300";
 361
 362                         Assert.AreEqual("972-324-9821", phone.Number);
 363                         Assert.AreEqual("300", phone.Extension);
 364                 }
 365
 366                 [Test]
 367                 public void ReadAdapter_WithNestedComponentOverridePrefix_WorksFine()
 368                 {
 369                         dictionary["HomeAddress_Emr_Number"] = "911";
 370
 371                         IPerson person = factory.GetAdapter<IPerson>(dictionary);
 372                         IPhone phone = person.HomeAddress.Emergency;
 373
 374                         Assert.AreEqual(dictionary["HomeAddress_Emr_Number"], phone.Number);
 375                         Assert.IsNull(dictionary["HomeAddress_Emr_Extension"]);
 376                 }
 377
 378                 [Test]
 379                 public void ReadAdapter_WithDefaultConversions_WorksFine()
 380                 {
 381                         DateTime now = DateTime.Now;
 382                         Guid guid = Guid.NewGuid();
 383
 384                         dictionary["Int"] = string.Format("{0}", 22);
 385                         dictionary["Float"] = string.Format("{0}", 98.6);
 386                         dictionary["Double"] = string.Format("{0}", 3.14D);
 387                         dictionary["Decimal"] = string.Format("{0}", 100M);
 388                         dictionary["String"] = "Hello World";
 389                         dictionary["DateTime"] = now.ToShortDateString();
 390                         dictionary["Guid"] = guid.ToString();
 391
 392                         IConversions conversions = factory.GetAdapter<IConversions>(dictionary);
 393                         Assert.AreEqual(22, conversions.Int);
 394                         Assert.AreEqual(98.6, conversions.Float);
 395                         Assert.AreEqual(3.14, conversions.Double);
 396                         Assert.AreEqual(100, conversions.Decimal);
 397                         Assert.AreEqual("Hello World", conversions.String);
 398                         Assert.AreEqual(now.Date, conversions.DateTime.Date);
 399                         Assert.AreEqual(guid, conversions.Guid);
 400                 }
 401
 402                 [Test]
 403                 public void UpdateAdapter_WithDefaultConversions_WorksFine()
 404                 {
 405                         DateTime today = DateTime.Today;
 406                         Guid guid = Guid.NewGuid();
 407
 408                         IConversionsToString conversions = factory.GetAdapter<IConversionsToString>(dictionary);
 409                         conversions.Int = 22;
 410                         conversions.Float = 98.6F;
 411                         conversions.Double = 3.14;
 412                         conversions.Decimal = 100;
 413                         conversions.DateTime = today;
 414                         conversions.Guid = guid;
 415                         conversions.Phone = new Phone("2124751012", "22");
 416
 417                         Assert.AreEqual(string.Format("{0}", 22), dictionary["Int"]);
 418                         Assert.AreEqual(string.Format("{0}", 98.6), dictionary["Float"]);
 419                         Assert.AreEqual(string.Format("{0}", 3.14D), dictionary["Double"]);
 420                         Assert.AreEqual(string.Format("{0}", 100M), dictionary["Decimal"]);
 421                         Assert.AreEqual(today.ToShortDateString(), dictionary["DateTime"]);
 422                         Assert.AreEqual(guid.ToString(), dictionary["Guid"]);
 423                         Assert.AreEqual("2124751012,22", dictionary["Phone"]);
 424                 }
 425
 426                 [Test]
 427                 public void ReadAdapter_WithDefaultNullableConversions_WorksFine()
 428                 {
 429                         DateTime? now = DateTime.Now;
 430                         Guid? guid = Guid.NewGuid();
 431
 432                         dictionary["NullInt"] = string.Format("{0}", 22);
 433                         dictionary["NullFloat"] = string.Format("{0}", 98.6);
 434                         dictionary["NullDouble"] = string.Format("{0}", 3.14D);
 435                         dictionary["NullDecimal"] = string.Format("{0}", 100M);
 436                         dictionary["NullDateTime"] = now.Value.ToShortDateString();
 437                         dictionary["NullGuid"] = guid.ToString();
 438
 439                         IConversions conversions = factory.GetAdapter<IConversions>(dictionary);
 440                         Assert.AreEqual(22, conversions.NullInt);
 441                         Assert.AreEqual(98.6, conversions.NullFloat);
 442                         Assert.AreEqual(3.14, conversions.NullDouble);
 443                         Assert.AreEqual(100, conversions.NullDecimal);
 444                         Assert.AreEqual(now.Value.Date, conversions.NullDateTime.Value.Date);
 445                         Assert.AreEqual(guid, conversions.NullGuid);
 446                 }
 447
 448                 [Test]
 449                 public void UpdateAdapter_WithDefaultNullableConversions_WorksFine()
 450                 {
 451                         DateTime? today = DateTime.Today;
 452                         Guid? guid = Guid.NewGuid();
 453
 454                         IConversionsToString conversions = factory.GetAdapter<IConversionsToString>(dictionary);
 455                         conversions.NullInt = 22;
 456                         conversions.NullFloat = 98.6F;
 457                         conversions.NullDouble = 3.14;
 458                         conversions.NullDecimal = 100;
 459                         conversions.NullDateTime = today;
 460                         conversions.NullGuid = guid;
 461
 462                         Assert.AreEqual(string.Format("{0}", 22), dictionary["NullInt"]);
 463                         Assert.AreEqual(string.Format("{0}", 98.6), dictionary["NullFloat"]);
 464                         Assert.AreEqual(string.Format("{0}", 3.14D), dictionary["NullDouble"]);
 465                         Assert.AreEqual(string.Format("{0}", 100M), dictionary["NullDecimal"]);
 466                         Assert.AreEqual(today.Value.ToShortDateString(), dictionary["NullDateTime"]);
 467                         Assert.AreEqual(guid.ToString(), dictionary["NullGuid"]);
 468                 }
 469
 470                 [Test]
 471                 public void ReadAdapter_WithDefaultNullConversions_WorksFine()
 472                 {
 473                         IConversions conversions = factory.GetAdapter<IConversions>(dictionary);
 474                         Assert.IsNull(conversions.NullInt);
 475                         Assert.IsNull(conversions.NullFloat);
 476                         Assert.IsNull(conversions.NullDouble);
 477                         Assert.IsNull(conversions.NullDecimal);
 478                         Assert.IsNull(conversions.NullDateTime);
 479                         Assert.IsNull(conversions.NullGuid);
 480                 }
 481
 482                 [Test]
 483                 public void UpdateAdapter_WithDefaultNullConversions_WorksFine()
 484                 {
 485                         IConversionsToString conversions = factory.GetAdapter<IConversionsToString>(dictionary);
 486                         conversions.NullInt = null;
 487                         conversions.NullFloat = null;
 488                         conversions.NullDecimal = null;
 489                         conversions.NullDateTime = null;
 490                         conversions.NullGuid = null;
 491
 492                         Assert.IsNull(dictionary["NullInt"]);
 493                         Assert.IsNull(dictionary["NullFloat"]);
 494                         Assert.IsNull(dictionary["NullDouble"]);
 495                         Assert.IsNull(dictionary["NullDecimal"]);
 496                         Assert.IsNull(dictionary["NullDateTime"]);
 497                         Assert.IsNull(dictionary["NullGuid"]);
 498                 }
 499
 500                 [Test]
 501                 public void ReadAdapter_WithStringLists_WorksFine()
 502                 {
 503                         dictionary["Names"] = "Craig,Brenda,Kaitlyn,Lauren,Matthew";
 504                         dictionary["Ages"] = "37,36,5,3,1";
 505
 506                         IStringLists lists = factory.GetAdapter<IStringLists>(dictionary);
 507
 508                         IList<string> names = lists.Names;
 509                         Assert.IsNotNull(names);
 510                         Assert.AreEqual(5, names.Count);
 511                         Assert.AreEqual("Craig", names[0]);
 512                         Assert.AreEqual("Brenda", names[1]);
 513                         Assert.AreEqual("Kaitlyn", names[2]);
 514                         Assert.AreEqual("Lauren", names[3]);
 515                         Assert.AreEqual("Matthew", names[4]);
 516
 517                         IList<int> ages = lists.Ages;
 518                         Assert.AreEqual(5, ages.Count);
 519                         Assert.AreEqual(37, ages[0]);
 520                         Assert.AreEqual(36, ages[1]);
 521                         Assert.AreEqual(5, ages[2]);
 522                         Assert.AreEqual(3, ages[3]);
 523                         Assert.AreEqual(1, ages[4]);
 524                 }
 525
 526                 [Test]
 527                 public void UpdateAdapter_WithStringLists_WorksFine()
 528                 {
 529                         IStringLists lists = factory.GetAdapter<IStringLists>(dictionary);
 530
 531                         IList<string> names = lists.Names;
 532                         names.Add("Craig");
 533                         names.Add("Brenda");
 534                         names.Add("Kaitlyn");
 535                         names.Add("Lauren");
 536                         names.Add("Matthew");
 537
 538                         Assert.AreEqual("Craig,Brenda,Kaitlyn,Lauren,Matthew", dictionary["Names"]);
 539
 540                         IList<int> ages = new List<int>();
 541                         ages.Add(37);
 542                         ages.Add(36);
 543                         ages.Add(5);
 544                         ages.Add(3);
 545                         ages.Add(1);
 546                         lists.Ages = ages;
 547
 548                         Assert.AreEqual("37,36,5,3,1", dictionary["Ages"]);
 549                 }
 550         }
 551
 552         public interface IPhone
 553         {
 554                 string Number { get; set; }
 555                 string Extension { get; set; }
 556         }
 557
 558         public class Phone : IPhone
 559         {
 560                 private string number;
 561                 private string extension;
 562
 563                 public Phone()
 564                 {
 565                 }
 566
 567                 public Phone(string number, string extension)
 568                 {
 569                         this.number = number;
 570                         this.extension = extension;
 571                 }
 572
 573                 public string Extension
 574                 {
 575                         get { return extension; }
 576                         set { extension = value; }
 577                 }
 578
 579                 public string Number
 580                 {
 581                         get { return number; }
 582                         set { number = value; }
 583                 }
 584         }
 585
 586         public interface IAddress
 587         {
 588                 string Line1 { get; set; }
 589                 string Line2 { get; set; }
 590                 string City { get; set; }
 591                 string State { get; set; }
 592                 string ZipCode { get; set; }
 593
 594                 [DictionaryComponent]
 595                 IPhone Phone { get; }
 596
 597                 [DictionaryComponent(NoPrefix = true)]
 598                 IPhone Mobile { get; }
 599
 600                 [DictionaryComponent(Prefix = "Emr_")]
 601                 IPhone Emergency { get; }
 602         }
 603
 604         public class Address : IAddress
 605         {
 606                 private string line1;
 607                 private string line2;
 608                 private string city;
 609                 private string state;
 610                 private string zipCode;
 611                 private IPhone phone;
 612                 private IPhone mobile;
 613                 private IPhone emergency;
 614
 615                 public string Line1
 616                 {
 617                         get { return line1; }
 618                         set { line1 = value; }
 619                 }
 620
 621                 public string Line2
 622                 {
 623                         get { return line2; }
 624                         set { line2 = value; }
 625                 }
 626
 627                 public string City
 628                 {
 629                         get { return city; }
 630                         set { city = value; }
 631                 }
 632
 633                 public string State
 634                 {
 635                         get { return state; }
 636                         set { state = value; }
 637                 }
 638
 639                 public string ZipCode
 640                 {
 641                         get { return zipCode; }
 642                         set { zipCode = value; }
 643                 }
 644
 645                 public IPhone Phone
 646                 {
 647                         get
 648                         {
 649                                 if (phone == null)
 650                                 {
 651                                         phone = new Phone();
 652                                 }
 653                                 return phone;
 654                         }
 655                 }
 656
 657                 public IPhone Mobile
 658                 {
 659                         get
 660                         {
 661                                 if (mobile == null)
 662                                 {
 663                                         mobile = new Phone();
 664                                 }
 665                                 return mobile;
 666                         }
 667                 }
 668
 669
 670                 public IPhone Emergency
 671                 {
 672                         get
 673                         {
 674                                 if (emergency == null)
 675                                 {
 676                                         emergency = new Phone();
 677                                 }
 678                                 return emergency;
 679                         }
 680                 }
 681         }
 682
 683         public interface IPerson
 684         {
 685                 string Name { get; set; }
 686
 687                 int Age { get; set; }
 688
 689                 DateTime DOB { get; set; }
 690
 691                 IList<IPerson> Friends { get; set; }
 692
 693                 [DictionaryKeySubstitution("_", " ")]
 694                 string First_Name { get; set; }
 695
 696                 [DictionaryComponent]
 697                 IAddress HomeAddress { get; set; }
 698
 699                 [DictionaryComponent(NoPrefix = true)]
 700                 IAddress WorkAddress { get; set; }
 701
 702                 [DictionaryComponent(Prefix = "Billing_")]
 703                 IAddress BillingAddress { get; set; }
 704         }
 705
 706         public interface IPersonWithoutPrefix : IPerson
 707         {
 708                 int NumberOfFeet { get; set; }
 709         }
 710
 711         [DictionaryKeyPrefix("Person_")]
 712         public interface IPersonWithPrefix : IPersonWithoutPrefix
 713         {
 714                 string HairColour { get; set; }
 715         }
 716
 717         [DictionaryKeyPrefix("Person2_")]
 718         public interface IPersonWithPrefixOverride : IPersonWithPrefix
 719         {
 720                 [DictionaryKey("Eye__Colour")]
 721                 string EyeColour { get; set; }
 722         }
 723
 724         public interface IPersonWithPrefixOverrideFurtherOverride : IPersonWithPrefixOverride
 725         {
 726                 int NumberOfHeads { get; set; }
 727         }
 728
 729         [DictionaryKeyPrefix("")]
 730         [DictionaryKeySubstitution("_", " ")]
 731         public interface IPersonWithDeniedInheritancePrefix : IPersonWithPrefixOverrideFurtherOverride
 732         {
 733                 int NumberOfFingers { get; set; }
 734
 735                 int Max_Width { get; set; }
 736         }
 737
 738         public interface IPersonWithMethod : IPerson
 739         {
 740                 void Run();
 741         }
 742
 743         public interface IConversions
 744         {
 745                 int Int { get; set; }
 746                 float Float { get; set; }
 747                 double Double { get; set; }
 748                 decimal Decimal { get; set; }
 749                 String String { get; set; }
 750                 DateTime DateTime { get; set; }
 751                 Guid Guid { get; set; }
 752                 int? NullInt { get; set; }
 753                 float? NullFloat { get; set; }
 754                 double? NullDouble { get; set; }
 755                 DateTime? NullDateTime { get; set; }
 756                 Guid? NullGuid { get; set; }
 757                 decimal? NullDecimal { get; set; }
 758         }
 759
 760         [DictionaryStringValues]
 761         public interface IConversionsToString : IConversions
 762         {
 763                 [TypeConverter(typeof(PhoneConverter))]
 764                 Phone Phone { get; set; }
 765         }
 766
 767         public interface IStringLists
 768         {
 769                 [DictionaryStringList]
 770                 IList<string> Names { get; }
 771
 772                 [DictionaryStringList]
 773                 IList<int> Ages { get; set; }
 774         }
 775
 776         public class PhoneConverter : TypeConverter
 777         {
 778                 public override bool CanConvertFrom(ITypeDescriptorContext context,
 779                                                     Type sourceType)
 780                 {
 781                         if (sourceType == typeof(string))
 782                         {
 783                                 return true;
 784                         }
 785                         return base.CanConvertFrom(context, sourceType);
 786                 }
 787
 788                 public override object ConvertFrom(ITypeDescriptorContext context,
 789                                                    CultureInfo culture, object value)
 790                 {
 791                         if (value is string)
 792                         {
 793                                 string[] fields = ((string) value).Split(new char[] {','});
 794                                 return new Phone(fields[0], fields[1]);
 795                         }
 796                         return base.ConvertFrom(context, culture, value);
 797                 }
 798
 799                 public override object ConvertTo(ITypeDescriptorContext context,
 800                                                  CultureInfo culture, object value, Type destinationType)
 801                 {
 802                         if (destinationType == typeof(string))
 803                         {
 804                                 return ((Phone) value).Number + "," + ((Phone) value).Extension;
 805                         }
 806                         return base.ConvertTo(context, culture, value, destinationType);
 807                 }
 808         }
 809 }