Components/Binder/Castle.Components.Binder.Tests/ConverterTestCase.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 namespace Castle.Components.Binder.Tests
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.Globalization;
  21         using System.Threading;
  22         using NUnit.Framework;
  23
  24         [TestFixture]
  25         public class ConverterTestCase
  26         {
  27                 private bool convSucceed;
  28                 private DefaultConverter converter;
  29
  30                 [TestFixtureSetUp]
  31                 public void Init()
  32                 {
  33                         converter = new DefaultConverter();
  34                 }
  35
  36                 [SetUp]
  37                 public void SetUp()
  38                 {
  39                         CultureInfo en = CultureInfo.CreateSpecificCulture("en");
  40
  41                         Thread.CurrentThread.CurrentCulture = en;
  42                         Thread.CurrentThread.CurrentUICulture = en;
  43                 }
  44
  45                 [Test]
  46                 public void StringConvert()
  47                 {
  48                         Assert.AreEqual("hello", Convert(typeof(string), "hello"));
  49                         Assert.IsTrue(convSucceed);
  50
  51                         Assert.AreEqual(null, Convert(typeof(string), null));
  52                         Assert.IsFalse(convSucceed);
  53
  54                         Assert.AreEqual("\n  \t", Convert(typeof(string), " \n  \t "));
  55                         Assert.IsTrue(convSucceed);
  56
  57                         Assert.AreEqual(null, Convert(typeof(string), ""));
  58                         Assert.IsTrue(convSucceed);
  59                 }
  60
  61                 [Test]
  62                 public void ArrayConvert()
  63                 {
  64                         Assert.AreEqual(new int[] {1, 2, 3}, Convert(typeof(int[]), "1,2,3"));
  65                         Assert.IsTrue(convSucceed);
  66
  67                         Assert.AreEqual(null, Convert(typeof(int[]), null));
  68                         Assert.IsFalse(convSucceed);
  69
  70                         Assert.AreEqual(new int[] {}, Convert(typeof(int[]), ""));
  71                         Assert.IsTrue(convSucceed);
  72                 }
  73
  74                 [Test]
  75                 public void EnumConvert()
  76                 {
  77                         Assert.AreEqual(UriPartial.Scheme, Convert(typeof(UriPartial), UriPartial.Scheme.ToString("D")));
  78                         Assert.IsTrue(convSucceed);
  79
  80                         Assert.AreEqual(UriPartial.Authority, Convert(typeof(UriPartial), UriPartial.Authority.ToString("D")));
  81                         Assert.IsTrue(convSucceed);
  82
  83                         Assert.AreEqual(UriPartial.Authority, Convert(typeof(UriPartial), "Authority"));
  84                         Assert.IsTrue(convSucceed);
  85
  86                         Assert.AreEqual(null, Convert(typeof(UriPartial), null));
  87                         Assert.IsFalse(convSucceed);
  88
  89                         Assert.AreEqual(null, Convert(typeof(UriPartial), "   "));
  90                         Assert.IsFalse(convSucceed);
  91
  92                         try
  93                         {
  94                                 Convert(typeof(UriPartial), "Invalid Value");
  95                                 Assert.Fail("EnumConvert should had throwed an exception");
  96                         }
  97                         catch(BindingException)
  98                         {
  99                                 Assert.IsFalse(convSucceed);
 100                         }
 101                 }
 102
 103                 [Test]
 104                 public void DecimalConvert()
 105                 {
 106                         Assert.AreEqual((decimal) 12.22, Convert(typeof(decimal), "12.22"));
 107                         Assert.IsTrue(convSucceed);
 108
 109                         Assert.AreEqual((decimal) 3000, Convert(typeof(decimal), "3,000.00"));
 110                         Assert.IsTrue(convSucceed);
 111
 112                         Assert.AreEqual(null, Convert(typeof(decimal), null));
 113                         Assert.IsFalse(convSucceed);
 114
 115                         Assert.AreEqual(null, Convert(typeof(decimal), "   "));
 116                         Assert.IsTrue(convSucceed);
 117
 118                         try
 119                         {
 120                                 Convert(typeof(decimal), "Invalid Value");
 121                                 Assert.Fail("DecimalConvert should had throwed an exception");
 122                         }
 123                         catch(BindingException)
 124                         {
 125                                 Assert.IsFalse(convSucceed);
 126                         }
 127                 }
 128
 129                 [Test]
 130                 public void GuidConvert()
 131                 {
 132                         Assert.AreEqual(new Guid("6CDEF425-6EEA-42AC-A318-0772B55FF259"),
 133                                         Convert(typeof(Guid), "6CDEF425-6EEA-42AC-A318-0772B55FF259"));
 134                         Assert.IsTrue(convSucceed);
 135
 136                         Assert.AreEqual(null, Convert(typeof(Guid), null));
 137                         Assert.IsFalse(convSucceed);
 138
 139                         Assert.AreEqual(null, Convert(typeof(Guid), "   "));
 140                         Assert.IsTrue(convSucceed);
 141
 142                         try
 143                         {
 144                                 Convert(typeof(Guid), "Invalid Value");
 145                                 Assert.Fail("GuidConvert should had throwed an exception");
 146                         }
 147                         catch(BindingException)
 148                         {
 149                                 Assert.IsFalse(convSucceed);
 150                         }
 151                 }
 152
 153                 [Test]
 154                 public void DateTimeConvert()
 155                 {
 156                         Assert.AreEqual(new DateTime(2005, 1, 31), Convert(typeof(DateTime), "2005-01-31"));
 157                         Assert.IsTrue(convSucceed);
 158
 159                         Convert(typeof(DateTime), null);
 160                         Assert.IsFalse(convSucceed);
 161
 162                         Convert(typeof(DateTime), "      ");
 163                         Assert.IsFalse(convSucceed);
 164                 }
 165
 166                 [Test]
 167                 public void InvalidDate1()
 168                 {
 169                         try
 170                         {
 171                                 Convert(typeof(DateTime), "Invalid Value");
 172                                 Assert.Fail("DateTimeConvert should had throwed an exception");
 173                         }
 174                         catch(BindingException)
 175                         {
 176                                 Assert.IsFalse(convSucceed);
 177                         }
 178                 }
 179
 180                 [Test]
 181                 public void InvalidDate2()
 182                 {
 183                         try
 184                         {
 185                                 Convert(typeof(DateTime), "2005-02-31");
 186                                 Assert.Fail("DateTimeConvert should had throwed an exception");
 187                         }
 188                         catch(BindingException)
 189                         {
 190                                 Assert.IsFalse(convSucceed);
 191                         }
 192                 }
 193
 194                 [Test]
 195                 public void Int32Convert()
 196                 {
 197                         Assert.AreEqual(12, Convert(typeof(int), "12"));
 198                         Assert.IsTrue(convSucceed);
 199
 200                         Assert.AreEqual(null, Convert(typeof(int), ""));
 201                         Assert.IsTrue(convSucceed);
 202
 203                         Assert.AreEqual(null, Convert(typeof(int), null));
 204                         Assert.IsFalse(convSucceed);
 205                 }
 206
 207                 [Test]
 208                 public void BooleanConvert()
 209                 {
 210                         Assert.AreEqual(false, Convert(typeof(bool), ""));
 211                         Assert.IsFalse(convSucceed);
 212
 213                         Assert.AreEqual(false, Convert(typeof(bool), "FalSE"));
 214                         Assert.IsTrue(convSucceed);
 215
 216                         Assert.AreEqual(true, Convert(typeof(bool), "1"));
 217                         Assert.IsTrue(convSucceed);
 218
 219                         Assert.AreEqual(false, Convert(typeof(bool), "0"));
 220                         Assert.IsTrue(convSucceed);
 221
 222                         Assert.AreEqual(true, Convert(typeof(bool), "true"));
 223                         Assert.IsTrue(convSucceed);
 224
 225                         Assert.AreEqual(true, Convert(typeof(bool), "on"));
 226                         Assert.IsTrue(convSucceed);
 227
 228                         Assert.AreEqual(null, Convert(typeof(bool), null));
 229                         Assert.IsFalse(convSucceed);
 230                 }
 231
 232                 [Test]
 233                 public void BooleanWithArrayAsSourceConvert()
 234                 {
 235                         Assert.AreEqual(true, ConvertFromArray(typeof(bool), new string[] {"1", "0"}));
 236                         Assert.IsTrue(convSucceed);
 237
 238                         Assert.AreEqual(false, ConvertFromArray(typeof(bool), new string[] {"0"}));
 239                         Assert.IsTrue(convSucceed);
 240
 241                         Assert.AreEqual(false, ConvertFromArray(typeof(bool), new string[] {"0", "0"}));
 242                         Assert.IsTrue(convSucceed);
 243                 }
 244
 245                 [Test]
 246                 public void PrimitiveConvert()
 247                 {
 248                         Assert.AreEqual(12.01, Convert(typeof(float), "12.01"));
 249                         Assert.IsTrue(convSucceed);
 250
 251                         Assert.AreEqual(null, Convert(typeof(float), ""));
 252                         Assert.IsTrue(convSucceed);
 253
 254                         Assert.AreEqual(null, Convert(typeof(float), null));
 255                         Assert.IsFalse(convSucceed);
 256                 }
 257
 258                 [Test]
 259                 public void TypeConverterConvert()
 260                 {
 261                         Assert.IsTrue(Convert(typeof(CustomType), "validvalue").GetType() == typeof(CustomType));
 262                         Assert.IsTrue(convSucceed);
 263
 264                         try
 265                         {
 266                                 Convert(typeof(CustomType), "invalid value");
 267                                 Assert.Fail("TypeConverterConvert should had throwed an exception");
 268                         }
 269                         catch(BindingException)
 270                         {
 271                         }
 272
 273                         try
 274                         {
 275                                 Convert(typeof(CustomType2), "validvalue");
 276                                 Assert.Fail("TypeConverterConvert should had throwed an exception");
 277                         }
 278                         catch(BindingException)
 279                         {
 280                         }
 281                 }
 282
 283                 [Test]
 284                 public void InstanceOfConvert()
 285                 {
 286                         ArrayList col = new ArrayList();
 287                         Assert.AreEqual(col, converter.Convert(typeof(ICollection), col, out convSucceed));
 288                         Assert.IsTrue(convSucceed);
 289                 }
 290
 291                 [Test]
 292                 public void NullableEnumConversion()
 293                 {
 294                         UriPartial? val = (UriPartial?) Convert(typeof(UriPartial?), "Path");
 295                         Assert.AreEqual(UriPartial.Path, val);
 296                         Assert.IsTrue(val.HasValue);
 297                         Assert.IsTrue(convSucceed);
 298
 299                         val = (UriPartial?) Convert(typeof(UriPartial?), "");
 300                         Assert.IsFalse(val.HasValue);
 301                         Assert.IsTrue(convSucceed);
 302
 303                         val = (UriPartial?) Convert(typeof(UriPartial?), "  ");
 304                         Assert.IsFalse(val.HasValue);
 305                         Assert.IsTrue(convSucceed);
 306
 307                         val = (UriPartial?) Convert(typeof(UriPartial?), null);
 308                         Assert.IsFalse(val.HasValue);
 309                         Assert.IsFalse(convSucceed);
 310                 }
 311
 312                 [Test]
 313                 public void NullableInt32Conversion()
 314                 {
 315                         int? val = (int?) Convert(typeof(int?), "");
 316                         Assert.IsFalse(val.HasValue);
 317                         Assert.IsTrue(convSucceed);
 318
 319                         val = (int?) Convert(typeof(int?), "  ");
 320                         Assert.IsFalse(val.HasValue);
 321                         Assert.IsTrue(convSucceed);
 322
 323                         Assert.AreEqual(null, Convert(typeof(int?), null));
 324                         Assert.IsFalse(convSucceed);
 325                 }
 326
 327                 [Test]
 328                 public void NullableDecimalConversion()
 329                 {
 330                         decimal? val = (decimal?) Convert(typeof(decimal?), "12.22");
 331                         Assert.AreEqual((decimal?) 12.22, val);
 332                         Assert.IsTrue(val.HasValue);
 333                         Assert.IsTrue(convSucceed);
 334
 335                         val = (decimal?) Convert(typeof(decimal?), "");
 336                         Assert.IsFalse(val.HasValue);
 337                         Assert.IsTrue(convSucceed);
 338
 339                         val = (decimal?) Convert(typeof(decimal?), "3,000.00");
 340                         Assert.AreEqual((decimal?) 3000, val);
 341                         Assert.IsTrue(val.HasValue);
 342                         Assert.IsTrue(convSucceed);
 343
 344                         val = (decimal?) Convert(typeof(decimal?), null);
 345                         Assert.IsFalse(val.HasValue);
 346                         Assert.IsFalse(convSucceed);
 347
 348                         val = (decimal?) Convert(typeof(decimal?), "   ");
 349                         Assert.IsFalse(val.HasValue);
 350                         Assert.IsTrue(convSucceed);
 351
 352                         try
 353                         {
 354                                 Convert(typeof(decimal?), "Invalid Value");
 355                                 Assert.Fail("DecimalConvert should had throwed an exception");
 356                         }
 357                         catch(BindingException)
 358                         {
 359                                 Assert.IsFalse(convSucceed);
 360                         }
 361                 }
 362
 363                 [Test]
 364                 public void NullableDateTimeConversion()
 365                 {
 366                         Assert.AreEqual(new DateTime?(new DateTime(2005, 1, 31)), Convert(typeof(DateTime?), "2005-01-31"));
 367                         Assert.IsTrue(convSucceed);
 368
 369                         Convert(typeof(DateTime?), null);
 370                         Assert.IsFalse(convSucceed);
 371
 372                         Convert(typeof(DateTime?), "      ");
 373                         Assert.IsTrue(convSucceed);
 374                 }
 375
 376                 [Test]
 377                 public void NullableBooleanConversion()
 378                 {
 379                         Assert.AreEqual(new bool?(), Convert(typeof(bool?), ""));
 380                         Assert.IsTrue(convSucceed);
 381
 382                         Assert.AreEqual(new bool?(), Convert(typeof(bool?), null));
 383                         Assert.IsFalse(convSucceed);
 384
 385                         Assert.AreEqual(new bool?(true), Convert(typeof(bool?), "1"));
 386                         Assert.IsTrue(convSucceed);
 387
 388                         Assert.AreEqual(new bool?(false), Convert(typeof(bool?), "0"));
 389                         Assert.IsTrue(convSucceed);
 390
 391                         Assert.AreEqual(new bool?(false), Convert(typeof(bool?), "0"));
 392                         Assert.IsTrue(convSucceed);
 393                 }
 394
 395                 [Test]
 396                 public void NullableBooleanWithArrayAsSourceConvert()
 397                 {
 398                         Assert.AreEqual(new bool?(true), ConvertFromArray(typeof(bool?), new string[] {"1", "0"}));
 399                         Assert.IsTrue(convSucceed);
 400
 401                         Assert.AreEqual(new bool?(false), ConvertFromArray(typeof(bool?), new string[] {"0"}));
 402                         Assert.IsTrue(convSucceed);
 403
 404                         Assert.AreEqual(new bool?(false), ConvertFromArray(typeof(bool?), new string[] {"0", "0"}));
 405                         Assert.IsTrue(convSucceed);
 406                 }
 407
 408                 [Test]
 409                 public void ListOfIntsConvert()
 410                 {
 411                         Type desiredType = typeof(System.Collections.Generic.List<int>);
 412
 413                         List<int> result;
 414
 415                         result = Convert(desiredType, "1,2,3") as List<int>;
 416
 417                         Assert.IsNotNull(result);
 418                         Assert.AreEqual(3, result.Count);
 419                         Assert.AreEqual(1, result[0]);
 420                         Assert.AreEqual(2, result[1]);
 421                         Assert.AreEqual(3, result[2]);
 422                         Assert.IsTrue(convSucceed);
 423
 424                         Assert.AreEqual(null, Convert(desiredType, null));
 425                         Assert.IsFalse(convSucceed);
 426
 427                         result = Convert(desiredType, "") as List<int>;
 428                         Assert.IsNotNull(result);
 429                         Assert.AreEqual(0, result.Count);
 430                         Assert.IsTrue(convSucceed);
 431                 }
 432
 433                 [Test]
 434                 public void ListOfStringsConvert()
 435                 {
 436                         Type desiredType = typeof(System.Collections.Generic.List<string>);
 437
 438                         List<string> result;
 439
 440                         result = Convert(desiredType, "1,2,3") as List<string>;
 441
 442                         Assert.IsNotNull(result);
 443                         Assert.AreEqual(3, result.Count);
 444                         Assert.AreEqual("1", result[0]);
 445                         Assert.AreEqual("2", result[1]);
 446                         Assert.AreEqual("3", result[2]);
 447                         Assert.IsTrue(convSucceed);
 448
 449                         Assert.AreEqual(null, Convert(desiredType, null));
 450                         Assert.IsFalse(convSucceed);
 451
 452                         result = Convert(desiredType, "") as List<string>;
 453                         Assert.IsNotNull(result);
 454                         Assert.AreEqual(0, result.Count);
 455                         Assert.IsTrue(convSucceed);
 456                 }
 457
 458                 private object Convert(Type desiredType, string input)
 459                 {
 460                         return converter.Convert(desiredType, typeof(string), input, out convSucceed);
 461                 }
 462
 463                 private object ConvertFromArray(Type desiredType, string[] input)
 464                 {
 465                         return converter.Convert(desiredType, typeof(string[]), input, out convSucceed);
 466                 }
 467         }
 468 }