mcs/class/corlib/Test/System/ConvertTest.cs

   1 // TestConvert.cs - NUnit Test Cases for System.Convert class
   2 //
   3 // Krister Hansson (ds99krha@thn.htu.se)
   4 // Andreas Jonsson (ds99anjn@thn.htu.se)
   5 //
   6 // (C) Krister Hansson & Andreas Jonsson
   7 //
   8
   9 using NUnit.Framework;
  10 using System;
  11 using System.Globalization;
  12
  13 namespace MonoTests.System {
  14
  15         [TestFixture]
  16         public class ConvertTest : Assertion {
  17
  18                 bool boolTrue;
  19                 bool boolFalse;
  20                 byte tryByte;
  21                 char tryChar;
  22                 DateTime tryDT;
  23                 decimal tryDec;
  24                 double tryDbl;
  25                 short tryInt16;
  26                 int tryInt32;
  27                 long tryInt64;
  28                 object tryObj;
  29                 sbyte trySByte;
  30                 float tryFloat;
  31                 string falseString;
  32                 string trueString;
  33                 string nullString;
  34                 string tryStr;
  35                 ushort tryUI16;
  36                 uint tryUI32;
  37                 ulong tryUI64;
  38                 CultureInfo ci;
  39
  40                 [SetUp]
  41                 public void SetUp ()
  42                 {
  43                         boolTrue = true;
  44                         boolFalse = false;
  45                         tryByte = 0;
  46                         tryChar = 'a';
  47                         tryDT = new DateTime(2002,1,1);
  48                         tryDec = 1234.2345m;
  49                         tryDbl = 0;
  50                         tryInt16 = 1234;
  51                         tryInt32 = 12345;
  52                         tryInt64 = 123456789012;
  53                         tryObj = new Object();
  54                         trySByte = 123;
  55                         tryFloat = 1234.2345f;
  56                         falseString = "false";
  57                         trueString = "true";
  58                         nullString = "null";
  59                         tryStr = "foobar";
  60                         tryUI16 = 34567;
  61                         tryUI32 = 567891234;
  62                         tryUI64 = 0;
  63                         ci = new CultureInfo("en-US");
  64                         ci.NumberFormat.NumberDecimalDigits = 3;
  65                 }
  66
  67                 public void TestChangeType() {
  68                         int iTest = 1;
  69                         try {
  70                                 AssertEquals("#A01", (short)12345, Convert.ChangeType(tryInt32, typeof(short)));
  71                                 iTest++;
  72                                 AssertEquals("#A02", 'A', Convert.ChangeType(65, typeof(char)));
  73                                 iTest++;
  74                                 AssertEquals("#A03", 66, Convert.ChangeType('B', typeof(int)));
  75                                 iTest++;
  76                                 AssertEquals("#A04", ((ulong)12345), Convert.ChangeType(tryInt32, typeof(ulong)));
  77
  78                                 iTest++;
  79                                 AssertEquals("#A05", true, Convert.ChangeType(tryDec, TypeCode.Boolean));
  80                                 iTest++;
  81                                 AssertEquals("#A06", 'f', Convert.ChangeType("f", TypeCode.Char));
  82                                 iTest++;
  83                                 AssertEquals("#A07", (decimal)123456789012, Convert.ChangeType(tryInt64, TypeCode.Decimal));
  84                                 iTest++;
  85                                 AssertEquals("#A08", (int)34567, Convert.ChangeType(tryUI16, TypeCode.Int32));
  86
  87                                 iTest++;
  88                                 AssertEquals("#A09", (double)567891234, Convert.ChangeType(tryUI32, typeof(double), ci));
  89                                 iTest++;
  90                                 AssertEquals("#A10", (ushort)0, Convert.ChangeType(tryByte, typeof(ushort), ci));
  91                                 iTest++;
  92                                 AssertEquals("#A11", (decimal)567891234, Convert.ChangeType(tryUI32, typeof(decimal), ci));
  93                                 iTest++;
  94                                 AssertEquals("#A12", (float)1234, Convert.ChangeType(tryInt16, typeof(float), ci));
  95                                 iTest++;
  96                                 AssertEquals("#A13", null, Convert.ChangeType(null, null, ci));
  97
  98                                 iTest++;
  99                                 AssertEquals("#A14", (decimal)0, Convert.ChangeType(tryByte, TypeCode.Decimal, ci));
 100                                 iTest++;
 101                                 AssertEquals("#A15", "f", Convert.ChangeType('f', TypeCode.String, ci));
 102                                 iTest++;
 103                                 AssertEquals("#A16", 'D', Convert.ChangeType(68, TypeCode.Char, ci));
 104                                 iTest++;
 105                                 AssertEquals("#A17", (long)34567, Convert.ChangeType(tryUI16, TypeCode.Int64, ci));
 106                                 iTest++;
 107                                 AssertEquals("#A18", null, Convert.ChangeType(null, TypeCode.Empty, ci));
 108                         } catch (Exception e) {
 109                                 Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
 110                         }
 111
 112                         try {
 113                                 Convert.ChangeType(boolTrue, typeof(char));
 114                                 Fail();
 115                         }
 116                         catch (Exception e) {
 117                                 AssertEquals("#A25", typeof(InvalidCastException), e.GetType());
 118                         }
 119
 120                         try {
 121                                 Convert.ChangeType(tryChar, typeof(DateTime));
 122                                 Fail();
 123                         }
 124                         catch (Exception e) {
 125                                 AssertEquals("#A26", typeof(InvalidCastException), e.GetType());
 126                         }
 127
 128                         try {
 129                                 Convert.ChangeType(ci, TypeCode.String);
 130                                 Fail();
 131                         }
 132                         catch (Exception e) {
 133                                 AssertEquals("#A27", typeof(InvalidCastException), e.GetType());
 134                         }
 135
 136                         try {
 137                                 Convert.ChangeType(tryInt32, null);
 138                                 Fail();
 139                         }
 140                         catch (Exception e) {
 141                                 AssertEquals("#A28", typeof(ArgumentNullException), e.GetType());
 142                         }
 143
 144                         try
 145                         {
 146                                 Convert.ChangeType(boolTrue, typeof(DateTime), ci);
 147                                 Fail();
 148                         }
 149                         catch (Exception e) {
 150                                 AssertEquals("#A29", typeof(InvalidCastException), e.GetType());
 151                         }
 152
 153                         try {
 154                                 Convert.ChangeType(ci, typeof(DateTime), ci);
 155                                 Fail();
 156                         }
 157                         catch (Exception e) {
 158                                 AssertEquals("#A30", typeof(InvalidCastException), e.GetType());
 159                         }
 160
 161                         /* Should throw ArgumentException but throws InvalidCastException
 162                         try {
 163                                 Convert.ChangeType(tryUI32, typeof(FormatException), ci);
 164                                 Fail();
 165                         }
 166                         catch (Exception e) {
 167                                 AssertEquals("#A??", typeof(ArgumentException), e.GetType());
 168                         }*/
 169
 170                         try {
 171                                 Convert.ChangeType(tryUI32, TypeCode.Byte, ci);
 172                                 Fail();
 173                         }
 174                         catch (Exception e) {
 175                                 AssertEquals("#A31", typeof(OverflowException), e.GetType());
 176                         }
 177
 178                         try {
 179                                 Convert.ChangeType(boolTrue, TypeCode.Char, ci);
 180                                 Fail();
 181                         }
 182                         catch (Exception e) {
 183                                 AssertEquals("#A32", typeof(InvalidCastException), e.GetType());
 184                         }
 185
 186                         try {
 187                                 Convert.ChangeType(boolTrue, null, ci);
 188                                 Fail();
 189                         }
 190                         catch (Exception e) {
 191                                 AssertEquals("#A33", typeof(ArgumentNullException), e.GetType());
 192                         }
 193
 194                         try {
 195                                 /* should fail to convert string to any enumeration type. */
 196                                 Convert.ChangeType("random string", typeof(DayOfWeek));
 197                                 Fail();
 198                         }
 199                         catch (Exception e) {
 200                                 AssertEquals("#A34", typeof(InvalidCastException), e.GetType());
 201                         }
 202
 203                 }
 204
 205                 public void TestGetTypeCode() {
 206                         int marker = 1;
 207                         try {
 208                                 AssertEquals("#B01", TypeCode.String, Convert.GetTypeCode(tryStr));
 209                                 marker++;
 210                                 AssertEquals("#B02", TypeCode.UInt16, Convert.GetTypeCode(tryUI16));
 211                                 marker++;
 212                                 AssertEquals("#B03", TypeCode.UInt32, Convert.GetTypeCode(tryUI32));
 213                                 marker++;
 214                                 AssertEquals("#B04", TypeCode.UInt64, Convert.GetTypeCode(tryUI64));
 215                                 marker++;
 216                                 AssertEquals("#B05", TypeCode.Double, Convert.GetTypeCode(tryDbl));
 217                                 marker++;
 218                                 AssertEquals("#B06", TypeCode.Int16, Convert.GetTypeCode(tryInt16));
 219                                 marker++;
 220                                 AssertEquals("#B07", TypeCode.Int64, Convert.GetTypeCode(tryInt64));
 221                                 marker++;
 222                                 AssertEquals("#B08", TypeCode.Object, Convert.GetTypeCode(tryObj));
 223                                 marker++;
 224                                 AssertEquals("#B09", TypeCode.SByte, Convert.GetTypeCode(trySByte));
 225                                 marker++;
 226                                 AssertEquals("#B10", TypeCode.Single, Convert.GetTypeCode(tryFloat));
 227                                 marker++;
 228                                 AssertEquals("#B11", TypeCode.Byte, Convert.GetTypeCode(tryByte));
 229                                 marker++;
 230                                 AssertEquals("#B12", TypeCode.Char, Convert.GetTypeCode(tryChar));
 231                                 marker++;
 232 //                              AssertEquals("#B13", TypeCode.DateTime, Convert.GetTypeCode(tryDT));
 233                                 marker++;
 234                                 AssertEquals("#B14", TypeCode.Decimal, Convert.GetTypeCode(tryDec));
 235                                 marker++;
 236                                 AssertEquals("#B15", TypeCode.Int32, Convert.GetTypeCode(tryInt32));
 237                                 marker++;
 238                                 AssertEquals("#B16", TypeCode.Boolean, Convert.GetTypeCode(boolTrue));
 239                         } catch (Exception e) {
 240                                 Fail ("Unexpected exception at " + marker + ": " + e);
 241                         }
 242                 }
 243
 244                 public void TestIsDBNull() {
 245                         AssertEquals("#C01", false, Convert.IsDBNull(tryInt32));
 246                         AssertEquals("#C02", true, Convert.IsDBNull(Convert.DBNull));
 247                         AssertEquals("#C03", false, Convert.IsDBNull(boolTrue));
 248                         AssertEquals("#C04", false, Convert.IsDBNull(tryChar));
 249                         AssertEquals("#C05", false, Convert.IsDBNull(tryFloat));
 250                 }
 251
 252                 public void TestToBoolean() {
 253                         tryObj = (object)tryDbl;
 254
 255                         AssertEquals("#D01", true, Convert.ToBoolean(boolTrue));
 256                         AssertEquals("#D02", false, Convert.ToBoolean(tryByte));
 257                         AssertEquals("#D03", true, Convert.ToBoolean(tryDec));
 258                         AssertEquals("#D04", false, Convert.ToBoolean(tryDbl));
 259                         AssertEquals("#D05", true, Convert.ToBoolean(tryInt16));
 260                         AssertEquals("#D06", true, Convert.ToBoolean(tryInt32));
 261                         AssertEquals("#D07", true, Convert.ToBoolean(tryInt64));
 262                         AssertEquals("#D08", false, Convert.ToBoolean(tryObj));
 263                         AssertEquals("#D09", true, Convert.ToBoolean(trySByte));
 264                         AssertEquals("#D10", true, Convert.ToBoolean(tryFloat));
 265                         AssertEquals("#D11", true, Convert.ToBoolean(trueString));
 266                         AssertEquals("#D12", false, Convert.ToBoolean(falseString));
 267                         AssertEquals("#D13", true, Convert.ToBoolean(tryUI16));
 268                         AssertEquals("#D14", true, Convert.ToBoolean(tryUI32));
 269                         AssertEquals("#D15", false, Convert.ToBoolean(tryUI64));
 270                         AssertEquals("#D16", false, Convert.ToBoolean(tryObj,ci));
 271                         AssertEquals("#D17", true, Convert.ToBoolean(trueString, ci));
 272                         AssertEquals("#D18", false, Convert.ToBoolean(falseString, ci));
 273
 274                         try {
 275                                 Convert.ToBoolean(tryChar);
 276                                 Fail();
 277                         }
 278                         catch (Exception e) {
 279                                 AssertEquals("#D20", typeof(InvalidCastException), e.GetType());
 280                         }
 281
 282                         try {
 283                                 Convert.ToBoolean(tryDT);
 284                                 Fail();
 285                         }
 286                         catch (Exception e) {
 287                                 AssertEquals("#D21", typeof(InvalidCastException), e.GetType());
 288                         }
 289
 290                         try {
 291                                 Convert.ToBoolean(tryStr);
 292                                 Fail();
 293                         }
 294                         catch (Exception e) {
 295                                 AssertEquals("#D22", typeof(FormatException), e.GetType());
 296                         }
 297
 298                         try {
 299                                 Convert.ToBoolean(nullString);
 300                                 Fail();
 301                         }
 302                         catch (Exception e) {
 303                                 AssertEquals("#D23", typeof(FormatException), e.GetType());
 304                         }
 305                 }
 306
 307                 public void TestToByte() {
 308
 309                         AssertEquals("#E01", (byte)1, Convert.ToByte(boolTrue));
 310                         AssertEquals("#E02", (byte)0, Convert.ToByte(boolFalse));
 311                         AssertEquals("#E03", tryByte, Convert.ToByte(tryByte));
 312                         AssertEquals("#E04", (byte)114, Convert.ToByte('r'));
 313                         AssertEquals("#E05", (byte)201, Convert.ToByte((decimal)200.6));
 314                         AssertEquals("#E06", (byte)125, Convert.ToByte((double)125.4));
 315                         AssertEquals("#E07", (byte)255, Convert.ToByte((short)255));
 316                         AssertEquals("#E08", (byte)254, Convert.ToByte((int)254));
 317                         AssertEquals("#E09", (byte)34, Convert.ToByte((long)34));
 318                         AssertEquals("#E10", (byte)1, Convert.ToByte((object)boolTrue));
 319                         AssertEquals("#E11", (byte)123, Convert.ToByte((float)123.49f));
 320                         AssertEquals("#E12", (byte)57, Convert.ToByte("57"));
 321                         AssertEquals("#E13", (byte)75, Convert.ToByte((ushort)75));
 322                         AssertEquals("#E14", (byte)184, Convert.ToByte((uint)184));
 323                         AssertEquals("#E15", (byte)241, Convert.ToByte((ulong)241));
 324                         AssertEquals("#E16", (byte)123, Convert.ToByte(trySByte, ci));
 325                         AssertEquals("#E17", (byte)27, Convert.ToByte("011011", 2));
 326                         AssertEquals("#E18", (byte)13, Convert.ToByte("15", 8));
 327                         AssertEquals("#E19", (byte)27, Convert.ToByte("27", 10));
 328                         AssertEquals("#E20", (byte)250, Convert.ToByte("FA", 16));
 329
 330                         try {
 331                                 Convert.ToByte('\u03A9'); // sign of Omega on Win2k
 332                                 Fail();
 333                         }
 334                         catch (Exception e) {
 335                                 AssertEquals("#E25", typeof(OverflowException), e.GetType());
 336                         }
 337
 338                         try {
 339                                 Convert.ToByte(tryDT);
 340                                 Fail();
 341                         }
 342                         catch (Exception e) {
 343                                 AssertEquals("#D26", typeof(InvalidCastException), e.GetType());
 344                         }
 345
 346                         try {
 347                                 Convert.ToByte((decimal)22000);
 348                                 Fail();
 349                         }
 350                         catch (Exception e) {
 351                                 AssertEquals("#E27", typeof(OverflowException), e.GetType());
 352                         }
 353
 354                         try {
 355                                 Convert.ToByte((double)255.5);
 356                                 Fail();
 357                         }
 358                         catch (Exception e) {
 359                                 AssertEquals("#E28", typeof(OverflowException), e.GetType());
 360                         }
 361
 362                         try {
 363                                 Convert.ToByte(-tryInt16);
 364                                 Fail();
 365                         }
 366                         catch (Exception e) {
 367                                 AssertEquals("#E29", typeof(OverflowException), e.GetType());
 368                         }
 369
 370                         try {
 371                                 Convert.ToByte((int)-256);
 372                                 Fail();
 373                         }
 374                         catch (Exception e) {
 375                                 AssertEquals("#E30", typeof(OverflowException), e.GetType());
 376                         }
 377
 378                         try {
 379                                 Convert.ToByte(tryInt64);
 380                                 Fail();
 381                         }
 382                         catch (Exception e) {
 383                                 AssertEquals("#E31", typeof(OverflowException), e.GetType());
 384                         }
 385
 386                         try {
 387                                 Convert.ToByte((object)ci);
 388                                 Fail();
 389                         }
 390                         catch (Exception e) {
 391                                 AssertEquals("#E32", typeof(InvalidCastException), e.GetType());
 392                         }
 393
 394                         try {
 395                                 Convert.ToByte((sbyte)-1);
 396                                 Fail();
 397                         }
 398                         catch (Exception e) {
 399                                 AssertEquals("#E33", typeof(OverflowException), e.GetType());
 400                         }
 401
 402                         try {
 403                                 Convert.ToByte((float)-0.6f);
 404                                 Fail();
 405                         }
 406                         catch (Exception e) {
 407                                 AssertEquals("#E34", typeof(OverflowException), e.GetType());
 408                         }
 409
 410                         try {
 411                                 Convert.ToByte("1a1");
 412                                 Fail();
 413                         }
 414                         catch (Exception e) {
 415                                 AssertEquals("#E35", typeof(FormatException), e.GetType());
 416                         }
 417
 418                         try {
 419                                 Convert.ToByte("457");
 420                                 Fail();
 421                         }
 422                         catch (Exception e) {
 423                                 AssertEquals("#E36", typeof(OverflowException), e.GetType());
 424                         }
 425
 426                         try {
 427                                 Convert.ToByte((ushort)30000);
 428                                 Fail();
 429                         }
 430                         catch (Exception e) {
 431                                 AssertEquals("#E37", typeof(OverflowException), e.GetType());
 432                         }
 433
 434                         try {
 435                                 Convert.ToByte((uint)300);
 436                                 Fail();
 437                         }
 438                         catch (Exception e) {
 439                                 AssertEquals("#E38", typeof(OverflowException), e.GetType());
 440                         }
 441
 442                         try {
 443                                 Convert.ToByte((ulong)987654321321);
 444                                 Fail();
 445                         }
 446                         catch (Exception e) {
 447                                 AssertEquals("#E39", typeof(OverflowException), e.GetType());
 448                         }
 449
 450                         try {
 451                                 Convert.ToByte("10010111", 3);
 452                                 Fail();
 453                         }
 454                         catch (Exception e) {
 455                                 AssertEquals("#E40", typeof(ArgumentException), e.GetType());
 456                         }
 457
 458                         try {
 459                                 Convert.ToByte("3F3", 16);
 460                                 Fail();
 461                         }
 462                         catch (Exception e) {
 463                                 AssertEquals("#E41", typeof(OverflowException), e.GetType());
 464                         }
 465                 }
 466
 467                 public void TestToChar(){
 468                         tryByte = 58;
 469                         AssertEquals("#F01", ':', Convert.ToChar(tryByte));
 470                         AssertEquals("#F02", 'a', Convert.ToChar(tryChar));
 471                         AssertEquals("#F03", 'A', Convert.ToChar((short)65));
 472                         AssertEquals("#F04", 'x', Convert.ToChar((int)120));
 473                         AssertEquals("#F05", '"', Convert.ToChar((long)34));
 474                         AssertEquals("#F06", '-', Convert.ToChar((sbyte)45));
 475                         AssertEquals("#F07", '@', Convert.ToChar("@"));
 476                         AssertEquals("#F08", 'K', Convert.ToChar((ushort)75));
 477                         AssertEquals("#F09", '=', Convert.ToChar((uint)61));
 478                         // AssertEquals("#F10", 'E', Convert.ToChar((ulong)200));
 479                         AssertEquals("#F11", '{', Convert.ToChar((object)trySByte, ci));
 480                         AssertEquals("#F12", 'o', Convert.ToChar(tryStr.Substring(1,1), ci));
 481
 482                         try {
 483                                 Convert.ToChar(boolTrue);
 484                                 Fail();
 485                         }
 486                         catch (Exception e) {
 487                                 AssertEquals("#F20", typeof(InvalidCastException), e.GetType());
 488                         }
 489
 490                         try {
 491                                 Convert.ToChar(tryDT);
 492                                 Fail();
 493                         }
 494                         catch (Exception e) {
 495                                 AssertEquals("#F21", typeof(InvalidCastException), e.GetType());
 496                         }
 497
 498                         try {
 499                                 Convert.ToChar(tryDec);
 500                                 Fail();
 501                         }
 502                         catch (Exception e) {
 503                                 AssertEquals("#F22", typeof(InvalidCastException), e.GetType());
 504                         }
 505
 506                         try {
 507                                 Convert.ToChar(tryDbl);
 508                                 Fail();
 509                         }
 510                         catch (Exception e) {
 511                                 AssertEquals("#F23", typeof(InvalidCastException), e.GetType());
 512                         }
 513
 514                         try {
 515                                 Convert.ToChar((short)-1);
 516                                 Fail();
 517                         }
 518                         catch (Exception e) {
 519                                 AssertEquals("#F24", typeof(OverflowException), e.GetType());
 520                         }
 521
 522                         try {
 523                                 Convert.ToChar(Int32.MinValue);
 524                                 Fail();
 525                         }
 526                         catch (Exception e) {
 527                                 AssertEquals("#F25", typeof(OverflowException), e.GetType());
 528                         }
 529
 530                         try {
 531                                 Convert.ToChar(Int32.MaxValue);
 532                                 Fail();
 533                         }
 534                         catch (Exception e) {
 535                                 AssertEquals("#F26", typeof(OverflowException), e.GetType());
 536                         }
 537
 538                         try {
 539                                 Convert.ToChar(tryInt64);
 540                                 Fail();
 541                         }
 542                         catch (Exception e) {
 543                                 AssertEquals("#F27", typeof(OverflowException), e.GetType());
 544                         }
 545
 546                         try {
 547                                 Convert.ToChar((long)-123);
 548                                 Fail();
 549                         }
 550                         catch (Exception e) {
 551                                 AssertEquals("#F28", typeof(OverflowException), e.GetType());
 552                         }
 553
 554                         try {
 555                                 Convert.ToChar(ci);
 556                                 Fail();
 557                         }
 558                         catch (Exception e) {
 559                                 AssertEquals("#F29", typeof(InvalidCastException), e.GetType());
 560                         }
 561
 562                         try {
 563                                 Convert.ToChar(-trySByte);
 564                                 Fail();
 565                         }
 566                         catch (Exception e) {
 567                                 AssertEquals("#F30", typeof(OverflowException), e.GetType());
 568                         }
 569
 570                         try {
 571                                 Convert.ToChar(tryFloat);
 572                                 Fail();
 573                         }
 574                         catch (Exception e) {
 575                                 AssertEquals("#F31", typeof(InvalidCastException), e.GetType());
 576                         }
 577
 578                         try {
 579                                 Convert.ToChar("foo");
 580                                 Fail();
 581                         }
 582                         catch (Exception e) {
 583                                 AssertEquals("#F32", typeof(FormatException), e.GetType());
 584                         }
 585
 586                         try {
 587                                 Convert.ToChar(null);
 588                                 Fail();
 589                         }
 590                         catch (Exception e) {
 591                                 AssertEquals("#F33", typeof(ArgumentNullException), e.GetType());
 592                         }
 593
 594                         try {
 595                                 Convert.ToChar(new Exception(), ci);
 596                                 Fail();
 597                         }
 598                         catch (Exception e) {
 599                                 AssertEquals("#F34", typeof(InvalidCastException), e.GetType());
 600                         }
 601
 602                         try {
 603                                 Convert.ToChar(null, ci);
 604                                 Fail();
 605                         }
 606                         catch (Exception e) {
 607                                 AssertEquals("#F35", typeof(ArgumentNullException), e.GetType());
 608                         }
 609
 610                         try {
 611                                 Convert.ToChar("", ci);
 612                                 Fail();
 613                         }
 614                         catch (Exception e) {
 615                                 AssertEquals("#F36", typeof(FormatException), e.GetType());
 616                         }
 617
 618                         try {
 619                                 Convert.ToChar(tryStr, ci);
 620                                 Fail();
 621                         }
 622                         catch (Exception e) {
 623                                 AssertEquals("#F37", typeof(FormatException), e.GetType());
 624                         }
 625                 }
 626
 627                 /*[Ignore ("http://bugzilla.ximian.com/show_bug.cgi?id=45286")]
 628                 [Test]
 629                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 630                 public void G22 () {
 631                         Convert.ToDateTime("20002-25-01");
 632                 } */
 633
 634                 public void TestToDateTime() {
 635                         string dateString = "01/01/2002";
 636                         int iTest = 1;
 637                         try {
 638                                 AssertEquals("#G01", tryDT, Convert.ToDateTime(tryDT));
 639                                 iTest++;
 640                                 AssertEquals("#G02", tryDT, Convert.ToDateTime(dateString));
 641                                 iTest++;
 642                                 AssertEquals("#G03", tryDT, Convert.ToDateTime(dateString, ci));
 643                         } catch (Exception e) {
 644                                 Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
 645                         }
 646
 647                         try {
 648                                 Convert.ToDateTime(boolTrue);
 649                                 Fail();
 650                         }
 651                         catch (Exception e) {
 652                                 AssertEquals("#G10", typeof(InvalidCastException), e.GetType());
 653                         }
 654
 655                         try {
 656                                 Convert.ToDateTime(tryByte);
 657                                 Fail();
 658                         }
 659                         catch (Exception e) {
 660                                 AssertEquals("#G11", typeof(InvalidCastException), e.GetType());
 661                         }
 662
 663                         try {
 664                                 Convert.ToDateTime(tryChar);
 665                                 Fail();
 666                         }
 667                         catch (Exception e) {
 668                                 AssertEquals("#G12", typeof(InvalidCastException), e.GetType());
 669                         }
 670
 671                         try {
 672                                 Convert.ToDateTime(tryDec);
 673                                 Fail();
 674                         }
 675                         catch (Exception e) {
 676                                 AssertEquals("#G13", typeof(InvalidCastException), e.GetType());
 677                         }
 678
 679                         try {
 680                                 Convert.ToDateTime(tryDbl);
 681                                 Fail();
 682                         }
 683                         catch (Exception e) {
 684                                 AssertEquals("#G14", typeof(InvalidCastException), e.GetType());
 685                         }
 686
 687                         try {
 688                                 Convert.ToDateTime(tryInt16);
 689                                 Fail();
 690                         }
 691                         catch (Exception e) {
 692                                 AssertEquals("#G15", typeof(InvalidCastException), e.GetType());
 693                         }
 694
 695                         try {
 696                                 Convert.ToDateTime(tryInt32);
 697                                 Fail();
 698                         }
 699                         catch (Exception e) {
 700                                 AssertEquals("#G16", typeof(InvalidCastException), e.GetType());
 701                         }
 702
 703                         try {
 704                                 Convert.ToDateTime(tryInt64);
 705                                 Fail();
 706                         }
 707                         catch (Exception e) {
 708                                 AssertEquals("#G17", typeof(InvalidCastException), e.GetType());
 709                         }
 710
 711                         try {
 712                                 Convert.ToDateTime(ci);
 713                                 Fail();
 714                         }
 715                         catch (Exception e) {
 716                                 AssertEquals("#G18", typeof(InvalidCastException), e.GetType());
 717                         }
 718
 719                         try {
 720                                 Convert.ToDateTime(trySByte);
 721                                 Fail();
 722                         }
 723                         catch (Exception e) {
 724                                 AssertEquals("#G19", typeof(InvalidCastException), e.GetType());
 725                         }
 726
 727                         try {
 728                                 Convert.ToDateTime(tryFloat);
 729                                 Fail();
 730                         }
 731                         catch (Exception e) {
 732                                 AssertEquals("#G20", typeof(InvalidCastException), e.GetType());
 733                         }
 734
 735                         try {
 736                                 Convert.ToDateTime("20a2-01-01");
 737                                 Fail();
 738                         }
 739                         catch (Exception e) {
 740                                 AssertEquals("#G21", typeof(FormatException), e.GetType());
 741                         }
 742
 743                         try {
 744                                 Convert.ToDateTime(tryUI16);
 745                                 Fail();
 746                         }
 747                         catch (Exception e) {
 748                                 AssertEquals("#G23", typeof(InvalidCastException), e.GetType());
 749                         }
 750
 751                         try {
 752                                 Convert.ToDateTime(tryUI32);
 753                                 Fail();
 754                         }
 755                         catch (Exception e) {
 756                                 AssertEquals("#G24", typeof(InvalidCastException), e.GetType());
 757                         }
 758
 759                         try {
 760                                 Convert.ToDateTime(tryUI64);
 761                                 Fail();
 762                         }
 763                         catch (Exception e) {
 764                                 AssertEquals("#G25", typeof(InvalidCastException), e.GetType());
 765                         }
 766
 767                         try {
 768                                 Convert.ToDateTime(ci, ci);
 769                                 Fail();
 770                         }
 771                         catch (Exception e) {
 772                                 AssertEquals("#G26", typeof(InvalidCastException), e.GetType());
 773                         }
 774
 775                         try {
 776                                 Convert.ToDateTime("20a2-01-01", ci);
 777                                 Fail();
 778                         }
 779                         catch (Exception e) {
 780                                 AssertEquals("#G27", typeof(FormatException), e.GetType());
 781                         }
 782
 783                         // this is supported by .net 1.1 (defect 41845)
 784                         try {
 785                                 Convert.ToDateTime("20022-01-01");
 786                                 Fail();
 787                         }
 788                         catch (Exception e) {
 789                                 AssertEquals("#G28", typeof(ArgumentOutOfRangeException), e.GetType());
 790                         }
 791
 792                         try {
 793                                 Convert.ToDateTime("2002-21-01");
 794                                 Fail();
 795                         }
 796                         catch (Exception e) {
 797                                 AssertEquals("#G29", typeof(FormatException), e.GetType());
 798                         }
 799
 800                         try {
 801                                 Convert.ToDateTime("2002-111-01");
 802                                 Fail();
 803                         }
 804                         catch (Exception e) {
 805                                 AssertEquals("#G30", typeof(FormatException), e.GetType());
 806                         }
 807
 808                         try {
 809                                 Convert.ToDateTime("2002-01-41");
 810                                 Fail();
 811                         }
 812                         catch (Exception e) {
 813                                 AssertEquals("#G31", typeof(FormatException), e.GetType());
 814                         }
 815
 816                         try {
 817                                 Convert.ToDateTime("2002-01-111");
 818                                 Fail();
 819                         }
 820                         catch (Exception e) {
 821                                 AssertEquals("#G32", typeof(FormatException), e.GetType());
 822                         }
 823
 824                         try {
 825                                 AssertEquals("#G33", tryDT, Convert.ToDateTime("2002-01-01"));
 826                         } catch (Exception e) {
 827                                 Fail ("Unexpected exception at #G33 " + e);
 828                         }
 829
 830                         try {
 831                                 Convert.ToDateTime("2002-01-11 34:11:11");
 832                                 Fail();
 833                         }
 834                         catch (Exception e) {
 835                                 AssertEquals("#G34", typeof(FormatException), e.GetType());
 836                         }
 837
 838                         try {
 839                                 Convert.ToDateTime("2002-01-11 11:70:11");
 840                                 Fail();
 841                         }
 842                         catch (Exception e) {
 843                                 AssertEquals("#G35", typeof(FormatException), e.GetType());
 844                         }
 845
 846                         try {
 847                                 Convert.ToDateTime("2002-01-11 11:11:70");
 848                                 Fail();
 849                         }
 850                         catch (Exception e) {
 851                                 AssertEquals("#G36", typeof(FormatException), e.GetType());
 852                         }
 853
 854                 }
 855
 856                 public void TestToDecimal() {
 857                         AssertEquals("#H01", (decimal)1, Convert.ToDecimal(boolTrue));
 858                         AssertEquals("#H02", (decimal)0, Convert.ToDecimal(boolFalse));
 859                         AssertEquals("#H03", (decimal)tryByte, Convert.ToDecimal(tryByte));
 860                         AssertEquals("#H04", tryDec, Convert.ToDecimal(tryDec));
 861                         AssertEquals("#H05", (decimal)tryDbl, Convert.ToDecimal(tryDbl));
 862                         AssertEquals("#H06", (decimal)tryInt16, Convert.ToDecimal(tryInt16));
 863                         AssertEquals("#H07", (decimal)tryInt32, Convert.ToDecimal(tryInt32));
 864                         AssertEquals("#H08", (decimal)tryInt64, Convert.ToDecimal(tryInt64));
 865                         AssertEquals("#H09", (decimal)trySByte, Convert.ToDecimal(trySByte));
 866                         AssertEquals("#H10", (decimal)tryFloat, Convert.ToDecimal(tryFloat));
 867                         string sep = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
 868 //                      AssertEquals("#H11", (decimal)23456.432, Convert.ToDecimal("23456" + sep + "432"));
 869 //                      Note: changed because the number were the same but with a different base
 870 //                      and this isn't a Convert bug (but a Decimal bug). See #60227 for more details.
 871 //                      http://bugzilla.ximian.com/show_bug.cgi?id=60227
 872                         Assert ("#H11", Decimal.Equals (23456.432m, Convert.ToDecimal ("23456" + sep + "432")));
 873                         AssertEquals("#H12", (decimal)tryUI16, Convert.ToDecimal(tryUI16));
 874                         AssertEquals("#H13", (decimal)tryUI32, Convert.ToDecimal(tryUI32));
 875                         AssertEquals("#H14", (decimal)tryUI64, Convert.ToDecimal(tryUI64));
 876                         AssertEquals("#H15", (decimal)63784, Convert.ToDecimal("63784", ci));
 877
 878                         try {
 879                                 Convert.ToDecimal(tryChar);
 880                                 Fail();
 881                         }
 882                         catch (Exception e) {
 883                                 AssertEquals("#H20", typeof(InvalidCastException), e.GetType());
 884                         }
 885
 886                         try {
 887                                 Convert.ToDecimal(tryDT);
 888                                 Fail();
 889                         }
 890                         catch (Exception e) {
 891                                 AssertEquals("#H21", typeof(InvalidCastException), e.GetType());
 892                         }
 893
 894                         try {
 895                                 Convert.ToDecimal(double.MaxValue);
 896                                 Fail();
 897                         }
 898                         catch (Exception e) {
 899                                 AssertEquals("#H22", typeof(OverflowException), e.GetType());
 900                         }
 901
 902                         try {
 903                                 Convert.ToDecimal(double.MinValue);
 904                                 Fail();
 905                         }
 906                         catch (Exception e) {
 907                                 AssertEquals("#H23", typeof(OverflowException), e.GetType());
 908                         }
 909
 910                         try {
 911                                 Convert.ToDecimal(ci);
 912                                 Fail();
 913                         }
 914                         catch (Exception e) {
 915                                 AssertEquals("#H24", typeof(InvalidCastException), e.GetType());
 916                         }
 917
 918                         try {
 919                                 Convert.ToDecimal(tryStr);
 920                                 Fail();
 921                         }
 922                         catch (Exception e) {
 923                                 AssertEquals("#H25", typeof(FormatException), e.GetType());
 924                         }
 925
 926                         try {
 927                                 string maxDec = decimal.MaxValue.ToString();
 928                                 maxDec = maxDec + "1";
 929                                 Convert.ToDecimal(maxDec);
 930                                 Fail();
 931                         }
 932                         catch (Exception e) {
 933                                 AssertEquals("#H26", typeof(OverflowException), e.GetType());
 934                         }
 935
 936                         try {
 937                                 Convert.ToDecimal(ci, ci);
 938                                 Fail();
 939                         }
 940                         catch (Exception e) {
 941                                 AssertEquals("#H27", typeof(InvalidCastException), e.GetType());
 942                         }
 943
 944                         try {
 945                                 Convert.ToDecimal(tryStr, ci);
 946                                 Fail();
 947                         }
 948                         catch (Exception e) {
 949                                 AssertEquals("#H28", typeof(FormatException), e.GetType());
 950                         }
 951
 952                         try {
 953                                 string maxDec = decimal.MaxValue.ToString();
 954                                 maxDec = maxDec + "1";
 955                                 Convert.ToDecimal(maxDec, ci);
 956                                 Fail();
 957                         }
 958                         catch (Exception e) {
 959                                 AssertEquals("#H29", typeof(OverflowException), e.GetType());
 960                         }
 961                 }
 962
 963                 public void TestToDouble() {
 964                         int iTest = 1;
 965                         try {
 966                                 AssertEquals("#I01", (double)1, Convert.ToDouble(boolTrue));
 967                                 iTest++;
 968                                 AssertEquals("#I02", (double)0, Convert.ToDouble(boolFalse));
 969                                 iTest++;
 970                                 AssertEquals("#I03", (double)tryByte, Convert.ToDouble(tryByte));
 971                                 iTest++;
 972                                 AssertEquals("#I04", tryDbl, Convert.ToDouble(tryDbl));
 973                                 iTest++;
 974                                 AssertEquals("#I05", (double)tryDec, Convert.ToDouble(tryDec));
 975                                 iTest++;
 976                                 AssertEquals("#I06", (double)tryInt16, Convert.ToDouble(tryInt16));
 977                                 iTest++;
 978                                 AssertEquals("#I07", (double)tryInt32, Convert.ToDouble(tryInt32));
 979                                 iTest++;
 980                                 AssertEquals("#I08", (double)tryInt64, Convert.ToDouble(tryInt64));
 981                                 iTest++;
 982                                 AssertEquals("#I09", (double)trySByte, Convert.ToDouble(trySByte));
 983                                 iTest++;
 984                                 AssertEquals("#I10", (double)tryFloat, Convert.ToDouble(tryFloat));
 985                                 iTest++;
 986                                 string sep = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
 987                                 AssertEquals("#I11", (double)23456.432, Convert.ToDouble("23456" + sep + "432"));
 988                                 iTest++;
 989                                 AssertEquals("#I12", (double)tryUI16, Convert.ToDouble(tryUI16));
 990                                 iTest++;
 991                                 AssertEquals("#I13", (double)tryUI32, Convert.ToDouble(tryUI32));
 992                                 iTest++;
 993                                 AssertEquals("#I14", (double)tryUI64, Convert.ToDouble(tryUI64));
 994                                 iTest++;
 995                                 AssertEquals("#H15", (double)63784, Convert.ToDouble("63784", ci));
 996                         } catch (Exception e) {
 997                                 Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
 998                         }
 999
1000                         try {
1001                                 Convert.ToDouble(tryChar);
1002                                 Fail();
1003                         }
1004                         catch (Exception e) {
1005                                 AssertEquals("#I20", typeof(InvalidCastException), e.GetType());
1006                         }
1007
1008                         try {
1009                                 Convert.ToDouble(tryDT);
1010                                 Fail();
1011                         }
1012                         catch (Exception e) {
1013                                 AssertEquals("#I21", typeof(InvalidCastException), e.GetType());
1014                         }
1015
1016                         try {
1017                                 Convert.ToDouble(ci);
1018                                 Fail();
1019                         }
1020                         catch (Exception e) {
1021                                 AssertEquals("#I22", typeof(InvalidCastException), e.GetType());
1022                         }
1023
1024                         try {
1025                                 Convert.ToDouble(tryStr);
1026                                 Fail();
1027                         }
1028                         catch (Exception e) {
1029                                 AssertEquals("#I23", typeof(FormatException), e.GetType());
1030                         }
1031
1032                         try {
1033                                 string maxDec = double.MaxValue.ToString();
1034                                 maxDec = maxDec + "1";
1035                                 Convert.ToDouble(maxDec);
1036                                 Fail();
1037                         }
1038                         catch (Exception e) {
1039                                 AssertEquals("#I24", typeof(OverflowException), e.GetType());
1040                         }
1041
1042                         try {
1043                                 Convert.ToDouble(ci, ci);
1044                                 Fail();
1045                         }
1046                         catch (Exception e) {
1047                                 AssertEquals("#I25", typeof(InvalidCastException), e.GetType());
1048                         }
1049
1050                         try {
1051                                 Convert.ToDouble(tryStr, ci);
1052                                 Fail();
1053                         }
1054                         catch (Exception e) {
1055                                 AssertEquals("#I26", typeof(FormatException), e.GetType());
1056                         }
1057
1058                         try {
1059                                 string maxDec = double.MaxValue.ToString();
1060                                 maxDec = maxDec + "1";
1061                                 Convert.ToDouble(maxDec, ci);
1062                                 Fail();
1063                         }
1064                         catch (Exception e) {
1065                                 AssertEquals("#I27", typeof(OverflowException), e.GetType());
1066                         }
1067
1068                         try {
1069                                 Convert.ToDouble(tryObj, ci);
1070                                 Fail();
1071                         }
1072                         catch (Exception e) {
1073                                 AssertEquals("#I28", typeof(InvalidCastException), e.GetType());
1074                         }
1075                 }
1076
1077                 public void TestToInt16() {
1078                         AssertEquals("#J01", (short)0, Convert.ToInt16(boolFalse));
1079                         AssertEquals("#J02", (short)1, Convert.ToInt16(boolTrue));
1080                         AssertEquals("#J03", (short)97, Convert.ToInt16(tryChar));
1081                         AssertEquals("#J04", (short)1234, Convert.ToInt16(tryDec));
1082                         AssertEquals("#J05", (short)0, Convert.ToInt16(tryDbl));
1083                         AssertEquals("#J06", (short)1234, Convert.ToInt16(tryInt16));
1084                         AssertEquals("#J07", (short)12345, Convert.ToInt16(tryInt32));
1085                         AssertEquals("#J08", (short)30000, Convert.ToInt16((long)30000));
1086                         AssertEquals("#J09", (short)123, Convert.ToInt16(trySByte));
1087                         AssertEquals("#J10", (short)1234, Convert.ToInt16(tryFloat));
1088                         AssertEquals("#J11", (short)578, Convert.ToInt16("578"));
1089                         AssertEquals("#J12", (short)15500, Convert.ToInt16((ushort)15500));
1090                         AssertEquals("#J13", (short)5489, Convert.ToInt16((uint)5489));
1091                         AssertEquals("#J14", (short)9876, Convert.ToInt16((ulong)9876));
1092                         AssertEquals("#J15", (short)14, Convert.ToInt16("14", ci));
1093                         AssertEquals("#J16", (short)11, Convert.ToInt16("01011", 2));
1094                         AssertEquals("#J17", (short)1540, Convert.ToInt16("3004", 8));
1095                         AssertEquals("#J18", (short)321, Convert.ToInt16("321", 10));
1096                         AssertEquals("#J19", (short)2748, Convert.ToInt16("ABC", 16));
1097
1098                         try {
1099                                 Convert.ToInt16(char.MaxValue);
1100                                 Fail();
1101                         }
1102                         catch (Exception e) {
1103                                 AssertEquals("#J25", typeof(OverflowException), e.GetType());
1104                         }
1105
1106                         try {
1107                                 Convert.ToInt16(tryDT);
1108                                 Fail();
1109                         }
1110                         catch (Exception e) {
1111                                 AssertEquals("#J26", typeof(InvalidCastException), e.GetType());
1112                         }
1113
1114                         try {
1115                                 Convert.ToInt16((decimal)(short.MaxValue + 1));
1116                                 Fail();
1117                         }
1118                         catch (Exception e) {
1119                                 AssertEquals("#J27", typeof(OverflowException), e.GetType());
1120                         }
1121
1122                         try {
1123                                 Convert.ToInt16((decimal)(short.MinValue - 1));
1124                                 Fail();
1125                         }
1126                         catch (Exception e) {
1127                                 AssertEquals("#J28", typeof(OverflowException), e.GetType());
1128                         }
1129
1130                         try {
1131                                 Convert.ToInt16((double)(short.MaxValue + 1));
1132                                 Fail();
1133                         }
1134                         catch (Exception e) {
1135                                 AssertEquals("#J29", typeof(OverflowException), e.GetType());
1136                         }
1137
1138                         try {
1139                                 Convert.ToInt16((double)(short.MinValue - 1));
1140                                 Fail();
1141                         }
1142                         catch (Exception e) {
1143                                 AssertEquals("#J30", typeof(OverflowException), e.GetType());
1144                         }
1145
1146                         try {
1147                                 Convert.ToInt16(50000);
1148                                 Fail();
1149                         }
1150                         catch (Exception e) {
1151                                 AssertEquals("#J31", typeof(OverflowException), e.GetType());
1152                         }
1153
1154                         try {
1155                                 Convert.ToInt16(-50000);
1156                                 Fail();
1157                         }
1158                         catch (Exception e) {
1159                                 AssertEquals("#J32", typeof(OverflowException), e.GetType());
1160                         }
1161
1162                         try {
1163                                 Convert.ToInt16(tryInt64);
1164                                 Fail();
1165                         }
1166                         catch (Exception e) {
1167                                 AssertEquals("#J33", typeof(OverflowException), e.GetType());
1168                         }
1169
1170                         try {
1171                                 Convert.ToInt16(-tryInt64);
1172                                 Fail();
1173                         }
1174                         catch (Exception e) {
1175                                 AssertEquals("#J34", typeof(OverflowException), e.GetType());
1176                         }
1177
1178                         try {
1179                                 Convert.ToInt16(tryObj);
1180                                 Fail();
1181                         }
1182                         catch (Exception e) {
1183                                 AssertEquals("#J35", typeof(InvalidCastException), e.GetType());
1184                         }
1185
1186                         try {
1187                                 Convert.ToInt16((float)32767.5);
1188                                 Fail();
1189                         }
1190                         catch (Exception e) {
1191                                 AssertEquals("#J36", typeof(OverflowException), e.GetType());
1192                         }
1193
1194                         try {
1195                                 Convert.ToInt16((float)-33000.54);
1196                                 Fail();
1197                         }
1198                         catch (Exception e) {
1199                                 AssertEquals("#J37", typeof(OverflowException), e.GetType());
1200                         }
1201
1202                         try {
1203                                 Convert.ToInt16(tryStr);
1204                                 Fail();
1205                         }
1206                         catch (Exception e) {
1207                                 AssertEquals("#J38", typeof(FormatException), e.GetType());
1208                         }
1209
1210                         try {
1211                                 Convert.ToInt16("-33000");
1212                                 Fail();
1213                         }
1214                         catch (Exception e) {
1215                                 AssertEquals("#J39", typeof(OverflowException), e.GetType());
1216                         }
1217
1218                         try {
1219                                 Convert.ToInt16(ushort.MaxValue);
1220                                 Fail();
1221                         }
1222                         catch (Exception e) {
1223                                 AssertEquals("#J40", typeof(OverflowException), e.GetType());
1224                         }
1225
1226                         try {
1227                                 Convert.ToInt16(uint.MaxValue);
1228                                 Fail();
1229                         }
1230                         catch (Exception e) {
1231                                 AssertEquals("#J41", typeof(OverflowException), e.GetType());
1232                         }
1233
1234                         try {
1235                                 Convert.ToInt16(ulong.MaxValue);
1236                                 Fail();
1237                         }
1238                         catch (Exception e) {
1239                                 AssertEquals("#J42", typeof(OverflowException), e.GetType());
1240                         }
1241
1242                         try {
1243                                 Convert.ToInt16(tryObj, ci);
1244                                 Fail();
1245                         }
1246                         catch (Exception e) {
1247                                 AssertEquals("#J43", typeof(InvalidCastException), e.GetType());
1248                         }
1249
1250                         try {
1251                                 Convert.ToInt16(tryStr, ci);
1252                                 Fail();
1253                         }
1254                         catch (Exception e) {
1255                                 AssertEquals("#J44", typeof(FormatException), e.GetType());
1256                         }
1257
1258                         try {
1259                                 Convert.ToInt16("-33000", ci);
1260                                 Fail();
1261                         }
1262                         catch (Exception e) {
1263                                 AssertEquals("#J45", typeof(OverflowException), e.GetType());
1264                         }
1265
1266                         try {
1267                                 Convert.ToInt16("321", 11);
1268                                 Fail();
1269                         }
1270                         catch (Exception e) {
1271                                 AssertEquals("#J46", typeof(ArgumentException), e.GetType());
1272                         }
1273
1274                         try {
1275                                 Convert.ToInt16("D8BF1", 16);
1276                                 Fail();
1277                         }
1278                         catch (Exception e) {
1279                                 AssertEquals("#J47", typeof(OverflowException), e.GetType());
1280                         }
1281                 }
1282
1283                 public void TestToInt32() {
1284                         long tryMax = long.MaxValue;
1285                         long tryMin = long.MinValue;
1286                         AssertEquals("#K01", (int)0, Convert.ToInt32(boolFalse));
1287                         AssertEquals("#K02", (int)1, Convert.ToInt32(boolTrue));
1288                         AssertEquals("#K03", (int)0, Convert.ToInt32(tryByte));
1289                         AssertEquals("#K04", (int)97, Convert.ToInt32(tryChar));
1290                         AssertEquals("#K05", (int)1234, Convert.ToInt32(tryDec));
1291                         AssertEquals("#K06", (int)0, Convert.ToInt32(tryDbl));
1292                         AssertEquals("#K07", (int)1234, Convert.ToInt32(tryInt16));
1293                         AssertEquals("#K08", (int)12345, Convert.ToInt32(tryInt32));
1294                         AssertEquals("#K09", (int)60000, Convert.ToInt32((long)60000));
1295                         AssertEquals("#K10", (int)123, Convert.ToInt32(trySByte));
1296                         AssertEquals("#K11", (int)1234, Convert.ToInt32(tryFloat));
1297                         AssertEquals("#K12", (int)9876, Convert.ToInt32((string)"9876"));
1298                         AssertEquals("#K13", (int)34567, Convert.ToInt32(tryUI16));
1299                         AssertEquals("#K14", (int)567891234, Convert.ToInt32(tryUI32));
1300                         AssertEquals("#K15", (int)0, Convert.ToInt32(tryUI64));
1301                         AssertEquals("#K16", (int)123, Convert.ToInt32("123", ci));
1302                         AssertEquals("#K17", (int)128, Convert.ToInt32("10000000", 2));
1303                         AssertEquals("#K18", (int)302, Convert.ToInt32("456", 8));
1304                         AssertEquals("#K19", (int)456, Convert.ToInt32("456", 10));
1305                         AssertEquals("#K20", (int)1110, Convert.ToInt32("456", 16));
1306
1307                         try {
1308                                 Convert.ToInt32(tryDT);
1309                                 Fail();
1310                         }
1311                         catch (Exception e) {
1312                                 AssertEquals("#K25", typeof(InvalidCastException), e.GetType());
1313                         }
1314
1315                         try {
1316                                 Convert.ToInt32((decimal)tryMax);
1317                                 Fail();
1318                         }
1319                         catch (Exception e) {
1320                                 AssertEquals("#K26", typeof(OverflowException), e.GetType());
1321                         }
1322
1323                         try {
1324                                 Convert.ToInt32((decimal)tryMin);
1325                                 Fail();
1326                         }
1327                         catch (Exception e) {
1328                                 AssertEquals("#K27", typeof(OverflowException), e.GetType());
1329                         }
1330
1331                         try {
1332                                 Convert.ToInt32((double)tryMax);
1333                                 Fail();
1334                         }
1335                         catch (Exception e) {
1336                                 AssertEquals("#K28", typeof(OverflowException), e.GetType());
1337                         }
1338
1339                         try {
1340                                 Convert.ToInt32((double)tryMin);
1341                                 Fail();
1342                         }
1343                         catch (Exception e) {
1344                                 AssertEquals("#K29", typeof(OverflowException), e.GetType());
1345                         }
1346
1347                         try {
1348                                 Convert.ToInt32(tryInt64);
1349                                 Fail();
1350                         }
1351                         catch (Exception e) {
1352                                 AssertEquals("#K30", typeof(OverflowException), e.GetType());
1353                         }
1354
1355                         try {
1356                                 Convert.ToInt32(-tryInt64);
1357                                 Fail();
1358                         }
1359                         catch (Exception e) {
1360                                 AssertEquals("#K31", typeof(OverflowException), e.GetType());
1361                         }
1362
1363                         try {
1364                                 Convert.ToInt32(tryObj);
1365                                 Fail();
1366                         }
1367                         catch (Exception e) {
1368                                 AssertEquals("#K32", typeof(InvalidCastException), e.GetType());
1369                         }
1370
1371                         try {
1372                                 Convert.ToInt32((float)tryMax);
1373                                 Fail();
1374                         }
1375                         catch (Exception e) {
1376                                 AssertEquals("#K33", typeof(OverflowException), e.GetType());
1377                         }
1378
1379                         try {
1380                                 Convert.ToInt32((float)tryMin);
1381                                 Fail();
1382                         }
1383                         catch (Exception e) {
1384                                 AssertEquals("#K34", typeof(OverflowException), e.GetType());
1385                         }
1386
1387                         try {
1388                                 Convert.ToInt32(tryStr, ci);
1389                                 Fail();
1390                         }
1391                         catch (Exception e) {
1392                                 AssertEquals("#K35", typeof(FormatException), e.GetType());
1393                         }
1394
1395                         try {
1396                                 Convert.ToInt32("-46565465123");
1397                                 Fail();
1398                         }
1399                         catch (Exception e) {
1400                                 AssertEquals("#K36", typeof(OverflowException), e.GetType());
1401                         }
1402
1403                         try {
1404                                 Convert.ToInt32("46565465123");
1405                                 Fail();
1406                         }
1407                         catch (Exception e) {
1408                                 AssertEquals("#K37", typeof(OverflowException), e.GetType());
1409                         }
1410
1411                         try {
1412                                 Convert.ToInt32((uint)tryMax);
1413                                 Fail();
1414                         }
1415                         catch (Exception e) {
1416                                 AssertEquals("#K38", typeof(OverflowException), e.GetType());
1417                         }
1418
1419                         try {
1420                                 Convert.ToInt32((ulong)tryMax);
1421                                 Fail();
1422                         }
1423                         catch (Exception e) {
1424                                 AssertEquals("#K39", typeof(OverflowException), e.GetType());
1425                         }
1426
1427                         try {
1428                                 Convert.ToInt32(tryObj, ci);
1429                                 Fail();
1430                         }
1431                         catch (Exception e) {
1432                                 AssertEquals("#K40", typeof(InvalidCastException), e.GetType());
1433                         }
1434
1435                         try {
1436                                 Convert.ToInt32(tryStr, ci);
1437                                 Fail();
1438                         }
1439                         catch (Exception e) {
1440                                 AssertEquals("#K41", typeof(FormatException), e.GetType());
1441                         }
1442
1443                         try {
1444                                 Convert.ToInt32("-46565465123", ci);
1445                                 Fail();
1446                         }
1447                         catch (Exception e) {
1448                                 AssertEquals("#K42", typeof(OverflowException), e.GetType());
1449                         }
1450
1451                         try {
1452                                 Convert.ToInt32("654", 9);
1453                                 Fail();
1454                         }
1455                         catch (Exception e) {
1456                                 AssertEquals("#K43", typeof(ArgumentException), e.GetType());
1457                         }
1458                 }
1459                 public void TestToInt64() {
1460                         decimal longMax = long.MaxValue;
1461                         longMax += 1000000;
1462                         decimal longMin = long.MinValue;
1463                         longMin -= 1000000;
1464
1465                         AssertEquals("#L01", (long)0, Convert.ToInt64(boolFalse));
1466                         AssertEquals("#L02", (long)1, Convert.ToInt64(boolTrue));
1467                         AssertEquals("#L03", (long)97, Convert.ToInt64(tryChar));
1468                         AssertEquals("#L04", (long)1234, Convert.ToInt64(tryDec));
1469                         AssertEquals("#L05", (long)0, Convert.ToInt64(tryDbl));
1470                         AssertEquals("#L06", (long)1234, Convert.ToInt64(tryInt16));
1471                         AssertEquals("#L07", (long)12345, Convert.ToInt64(tryInt32));
1472                         AssertEquals("#L08", (long)123456789012, Convert.ToInt64(tryInt64));
1473                         AssertEquals("#L09", (long)123, Convert.ToInt64(trySByte));
1474                         AssertEquals("#L10", (long)1234, Convert.ToInt64(tryFloat));
1475                         AssertEquals("#L11", (long)564897, Convert.ToInt64("564897"));
1476                         AssertEquals("#L12", (long)34567, Convert.ToInt64(tryUI16));
1477                         AssertEquals("#L13", (long)567891234, Convert.ToInt64(tryUI32));
1478                         AssertEquals("#L14", (long)0, Convert.ToInt64(tryUI64));
1479                         AssertEquals("#L15", (long)-2548751, Convert.ToInt64("-2548751", ci));
1480                         AssertEquals("#L16", (long)24987562, Convert.ToInt64("1011111010100011110101010", 2));
1481                         AssertEquals("#L17", (long)-24578965, Convert.ToInt64("1777777777777642172153", 8));
1482                         AssertEquals("#L18", (long)248759757, Convert.ToInt64("248759757", 10));
1483                         AssertEquals("#L19", (long)256, Convert.ToInt64("100", 16));
1484
1485                         try {
1486                                 Convert.ToInt64(tryDT);
1487                                 Fail();
1488                         }
1489                         catch (Exception e) {
1490                                 AssertEquals("#L20", typeof(InvalidCastException), e.GetType());
1491                         }
1492
1493                         try {
1494                                 Convert.ToInt64((decimal)longMax + 1);
1495                                 Fail();
1496                         }
1497                         catch (Exception e) {
1498                                 AssertEquals("#L21", typeof(OverflowException), e.GetType());
1499                         }
1500
1501                         try {
1502                                 Convert.ToInt64((decimal)longMin);
1503                                 Fail();
1504                         }
1505                         catch (Exception e) {
1506                                 AssertEquals("#L24", typeof(OverflowException), e.GetType());
1507                         }
1508
1509                         try {
1510                                 Convert.ToInt64((double)longMax);
1511                                 Fail();
1512                         }
1513                         catch (Exception e) {
1514                                 AssertEquals("#L25:"+longMax, typeof(OverflowException), e.GetType());
1515                         }
1516
1517                         try {
1518                                 Convert.ToInt64((double)longMin);
1519                                 Fail();
1520                         }
1521                         catch (Exception e) {
1522                                 AssertEquals("#L26", typeof(OverflowException), e.GetType());
1523                         }
1524
1525                         try {
1526                                 Convert.ToInt64(new Exception());
1527                                 Fail();
1528                         }
1529                         catch (Exception e) {
1530                                 AssertEquals("#L27", typeof(InvalidCastException), e.GetType());
1531                         }
1532
1533                         try {
1534                                 Convert.ToInt64(((float)longMax)*100);
1535                                 Fail();
1536                         }
1537                         catch (Exception e) {
1538                                 AssertEquals("#L28:"+longMax, typeof(OverflowException), e.GetType());
1539                         }
1540
1541                         try {
1542                                 Convert.ToInt64(((float)longMin)*100);
1543                                 Fail();
1544                         }
1545                         catch (Exception e) {
1546                                 AssertEquals("#L29", typeof(OverflowException), e.GetType());
1547                         }
1548
1549                         try {
1550                                 Convert.ToInt64("-567b3");
1551                                 Fail();
1552                         }
1553                         catch (Exception e) {
1554                                 AssertEquals("#L30", typeof(FormatException), e.GetType());
1555                         }
1556
1557                         try {
1558                                 Convert.ToInt64(longMax.ToString());
1559                                 Fail();
1560                         }
1561                         catch (Exception e) {
1562                                 AssertEquals("#L31:", typeof(OverflowException), e.GetType());
1563                         }
1564
1565                         try {
1566                                 Convert.ToInt64(ulong.MaxValue);
1567                                 Fail();
1568                         }
1569                         catch (Exception e) {
1570                                 AssertEquals("#L32", typeof(OverflowException), e.GetType());
1571                         }
1572
1573                         try {
1574                                 Convert.ToInt64(tryStr, ci);
1575                                 Fail();
1576                         }
1577                         catch (Exception e) {
1578                                 AssertEquals("#L32b", typeof(FormatException), e.GetType());
1579                         }
1580
1581                         try {
1582                                 Convert.ToInt64(longMin.ToString(), ci);
1583                                 Fail();
1584                         }
1585                         catch (Exception e) {
1586                                 AssertEquals("#L33", typeof(OverflowException), e.GetType());
1587                         }
1588
1589                         try {
1590                                 Convert.ToInt64("321", 11);
1591                                 Fail();
1592                         }
1593                         catch (Exception e) {
1594                                 AssertEquals("#L34", typeof(ArgumentException), e.GetType());
1595                         }
1596                 }
1597
1598                 public void TestToSByte() {
1599                         int iTest = 1;
1600                         try {
1601                                 AssertEquals("#M01", (sbyte)0, Convert.ToSByte(boolFalse));
1602                                 iTest++;
1603                                 AssertEquals("#M02", (sbyte)1, Convert.ToSByte(boolTrue));
1604                                 iTest++;
1605                                 AssertEquals("#M03", (sbyte)97, Convert.ToSByte(tryChar));
1606                                 iTest++;
1607                                 AssertEquals("#M04", (sbyte)15, Convert.ToSByte((decimal)15));
1608                                 iTest++;
1609                                 AssertEquals("#M05", (sbyte)0, Convert.ToSByte(tryDbl));
1610                                 iTest++;
1611                                 AssertEquals("#M06", (sbyte)127, Convert.ToSByte((short)127));
1612                                 iTest++;
1613                                 AssertEquals("#M07", (sbyte)-128, Convert.ToSByte((int)-128));
1614                                 iTest++;
1615                                 AssertEquals("#M08", (sbyte)30, Convert.ToSByte((long)30));
1616                                 iTest++;
1617                                 AssertEquals("#M09", (sbyte)123, Convert.ToSByte(trySByte));
1618                                 iTest++;
1619                                 AssertEquals("#M10", (sbyte)12, Convert.ToSByte((float)12.46987f));
1620                                 iTest++;
1621                                 AssertEquals("#M11", (sbyte)1, Convert.ToSByte("1"));
1622                                 iTest++;
1623                                 AssertEquals("#M12", (sbyte)99, Convert.ToSByte((ushort)99));
1624                                 iTest++;
1625                                 AssertEquals("#M13", (sbyte)54, Convert.ToSByte((uint)54));
1626                                 iTest++;
1627                                 AssertEquals("#M14", (sbyte)127, Convert.ToSByte((ulong)127));
1628                                 iTest++;
1629                                 AssertEquals("#M15", (sbyte)14, Convert.ToSByte("14", ci));
1630                                 iTest++;
1631                                 AssertEquals("#M16", (sbyte)11, Convert.ToSByte("01011", 2));
1632                                 iTest++;
1633                                 AssertEquals("#M17", (sbyte)5, Convert.ToSByte("5", 8));
1634                                 iTest++;
1635                                 AssertEquals("#M18", (sbyte)100, Convert.ToSByte("100", 10));
1636                                 iTest++;
1637                                 AssertEquals("#M19", (sbyte)-1, Convert.ToSByte("FF", 16));
1638                         } catch (Exception e) {
1639                                 Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
1640                         }
1641
1642                         try {
1643                                 Convert.ToSByte((byte)200);
1644                                 Fail();
1645                         }
1646                         catch (Exception e) {
1647                                 AssertEquals("#M25", typeof(OverflowException), e.GetType());
1648                         }
1649
1650                         try {
1651                                 Convert.ToSByte((char)130);
1652                                 Fail();
1653                         }
1654                         catch (Exception e) {
1655                                 AssertEquals("#M26", typeof(OverflowException), e.GetType());
1656                         }
1657
1658                         try {
1659                                 Convert.ToSByte(tryDT);
1660                                 Fail();
1661                         }
1662                         catch (Exception e) {
1663                                 AssertEquals("#M27", typeof(InvalidCastException), e.GetType());
1664                         }
1665
1666                         try {
1667                                 Convert.ToSByte((decimal)127.5m);
1668                                 Fail();
1669                         }
1670                         catch (Exception e) {
1671                                 AssertEquals("#M28", typeof(OverflowException), e.GetType());
1672                         }
1673
1674                         try {
1675                                 Convert.ToSByte((decimal)-200m);
1676                                 Fail();
1677                         }
1678                         catch (Exception e) {
1679                                 AssertEquals("#M29", typeof(OverflowException), e.GetType());
1680                         }
1681
1682                         try {
1683                                 Convert.ToSByte((double)150);
1684                                 Fail();
1685                         }
1686                         catch (Exception e) {
1687                                 AssertEquals("#M30", typeof(OverflowException), e.GetType());
1688                         }
1689
1690                         try {
1691                                 Convert.ToSByte((double)-128.6);
1692                                 Fail();
1693                         }
1694                         catch (Exception e) {
1695                                 AssertEquals("#M31", typeof(OverflowException), e.GetType());
1696                         }
1697
1698                         try {
1699                                 Convert.ToSByte((short)150);
1700                                 Fail();
1701                         }
1702                         catch (Exception e) {
1703                                 AssertEquals("#M32", typeof(OverflowException), e.GetType());
1704                         }
1705
1706                         try {
1707                                 Convert.ToSByte((short)-300);
1708                                 Fail();
1709                         }
1710                         catch (Exception e) {
1711                                 AssertEquals("#M33", typeof(OverflowException), e.GetType());
1712                         }
1713
1714                         try {
1715                                 Convert.ToSByte((int)1500);
1716                                 Fail();
1717                         }
1718                         catch (Exception e) {
1719                                 AssertEquals("#M34", typeof(OverflowException), e.GetType());
1720                         }
1721
1722                         try {
1723                                 Convert.ToSByte((int)-1286);
1724                                 Fail();
1725                         }
1726                         catch (Exception e) {
1727                                 AssertEquals("#M35", typeof(OverflowException), e.GetType());
1728                         }
1729
1730                         try {
1731                                 Convert.ToSByte((long)128);
1732                                 Fail();
1733                         }
1734                         catch (Exception e) {
1735                                 AssertEquals("#M36", typeof(OverflowException), e.GetType());
1736                         }
1737
1738                         try {
1739                                 Convert.ToSByte((long)-129);
1740                                 Fail();
1741                         }
1742                         catch (Exception e) {
1743                                 AssertEquals("#M37", typeof(OverflowException), e.GetType());
1744                         }
1745
1746                         try {
1747                                 Convert.ToSByte(new NumberFormatInfo());
1748                                 Fail();
1749                         }
1750                         catch (Exception e) {
1751                                 AssertEquals("#M38", typeof(InvalidCastException), e.GetType());
1752                         }
1753
1754                         try {
1755                                 Convert.ToSByte((float)333);
1756                                 Fail();
1757                         }
1758                         catch (Exception e) {
1759                                 AssertEquals("#M39", typeof(OverflowException), e.GetType());
1760                         }
1761
1762                         try {
1763                                 Convert.ToSByte((float)-666);
1764                                 Fail();
1765                         }
1766                         catch (Exception e) {
1767                                 AssertEquals("#M40", typeof(OverflowException), e.GetType());
1768                         }
1769
1770                         try {
1771                                 Convert.ToSByte("B3");
1772                                 Fail();
1773                         }
1774                         catch (Exception e) {
1775                                 AssertEquals("#M41", typeof(FormatException), e.GetType());
1776                         }
1777
1778                         try {
1779                                 Convert.ToSByte("251");
1780                                 Fail();
1781                         }
1782                         catch (Exception e) {
1783                                 AssertEquals("#M42", typeof(OverflowException), e.GetType());
1784                         }
1785
1786                         try {
1787                                 Convert.ToSByte(ushort.MaxValue);
1788                                 Fail();
1789                         }
1790                         catch (Exception e) {
1791                                 AssertEquals("#M43", typeof(OverflowException), e.GetType());
1792                         }
1793
1794                         try {
1795                                 Convert.ToSByte((uint)600);
1796                                 Fail();
1797                         }
1798                         catch (Exception e) {
1799                                 AssertEquals("#M44", typeof(OverflowException), e.GetType());
1800                         }
1801
1802                         try {
1803                                 Convert.ToSByte(ulong.MaxValue);
1804                                 Fail();
1805                         }
1806                         catch (Exception e) {
1807                                 AssertEquals("#M45", typeof(OverflowException), e.GetType());
1808                         }
1809
1810                         try {
1811                                 Convert.ToSByte(ci, ci);
1812                                 Fail();
1813                         }
1814                         catch (Exception e) {
1815                                 AssertEquals("#M46", typeof(InvalidCastException), e.GetType());
1816                         }
1817
1818                         try {
1819                                 Convert.ToSByte(tryStr, ci);
1820                                 Fail();
1821                         }
1822                         catch (Exception e) {
1823                                 AssertEquals("#M47", typeof(FormatException), e.GetType());
1824                         }
1825
1826                         try {
1827                                 Convert.ToSByte("325", ci);
1828                                 Fail();
1829                         }
1830                         catch (Exception e) {
1831                                 AssertEquals("#M48", typeof(OverflowException), e.GetType());
1832                         }
1833
1834                         try {
1835                                 Convert.ToSByte("5D", 15);
1836                                 Fail();
1837                         }
1838                         catch (Exception e) {
1839                                 AssertEquals("#M49", typeof(ArgumentException), e.GetType());
1840                         }
1841
1842                         try {
1843                                 Convert.ToSByte("111111111", 2);
1844                                 Fail();
1845                         }
1846                         catch (Exception e) {
1847                                 AssertEquals("#M50", typeof(OverflowException), e.GetType());
1848                         }
1849                 }
1850
1851                 public void TestToSingle() {
1852                         int iTest = 1;
1853                         try {
1854                                 AssertEquals("#N01", (float)0, Convert.ToSingle(boolFalse));
1855                                 iTest++;
1856                                 AssertEquals("#N02", (float)1, Convert.ToSingle(boolTrue));
1857                                 iTest++;
1858                                 AssertEquals("#N03", (float)0, Convert.ToSingle(tryByte));
1859                                 iTest++;
1860                                 AssertEquals("#N04", (float)1234,234, Convert.ToSingle(tryDec));
1861                                 iTest++;
1862                                 AssertEquals("#N05", (float)0, Convert.ToSingle(tryDbl));
1863                                 iTest++;
1864                                 AssertEquals("#N06", (float)1234, Convert.ToSingle(tryInt16));
1865                                 iTest++;
1866                                 AssertEquals("#N07", (float)12345, Convert.ToSingle(tryInt32));
1867                                 iTest++;
1868                                 AssertEquals("#N08", (float)123456789012, Convert.ToSingle(tryInt64));
1869                                 iTest++;
1870                                 AssertEquals("#N09", (float)123, Convert.ToSingle(trySByte));
1871                                 iTest++;
1872                                 AssertEquals("#N10", (float)1234,2345, Convert.ToSingle(tryFloat));
1873                                 iTest++;
1874                                 AssertEquals("#N11", (float)987, Convert.ToSingle("987"));
1875                                 iTest++;
1876                                 AssertEquals("#N12", (float)34567, Convert.ToSingle(tryUI16));
1877                                 iTest++;
1878                                 AssertEquals("#N13", (float)567891234, Convert.ToSingle(tryUI32));
1879                                 iTest++;
1880                                 AssertEquals("#N14", (float)0, Convert.ToSingle(tryUI64));
1881                                 iTest++;
1882                                 AssertEquals("#N15", (float)654.234, Convert.ToSingle("654.234", ci));
1883                         } catch (Exception e) {
1884                                 Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
1885                         }
1886
1887                         try {
1888                                 Convert.ToSingle(tryChar);
1889                                 Fail();
1890                         }
1891                         catch (Exception e) {
1892                                 AssertEquals("#N25", typeof(InvalidCastException), e.GetType());
1893                         }
1894
1895                         try {
1896                                 Convert.ToSingle(tryDT);
1897                                 Fail();
1898                         }
1899                         catch (Exception e) {
1900                                 AssertEquals("#N26", typeof(InvalidCastException), e.GetType());
1901                         }
1902
1903                         try {
1904                                 Convert.ToSingle(tryObj);
1905                                 Fail();
1906                         }
1907                         catch (Exception e) {
1908                                 AssertEquals("#N27", typeof(InvalidCastException), e.GetType());
1909                         }
1910
1911                         try {
1912                                 Convert.ToSingle("A345H");
1913                                 Fail();
1914                         }
1915                         catch (Exception e) {
1916                                 AssertEquals("#N28", typeof(FormatException), e.GetType());
1917                         }
1918
1919                         try {
1920                                 Convert.ToSingle(double.MaxValue.ToString());
1921                                 Fail();
1922                         }
1923                         catch (Exception e) {
1924                                 AssertEquals("#N29", typeof(OverflowException), e.GetType());
1925                         }
1926
1927                         try {
1928                                 Convert.ToSingle(tryObj, ci);
1929                                 Fail();
1930                         }
1931                         catch (Exception e) {
1932                                 AssertEquals("#N30", typeof(InvalidCastException), e.GetType());
1933                         }
1934
1935                         try {
1936                                 Convert.ToSingle("J345K", ci);
1937                                 Fail();
1938                         }
1939                         catch (Exception e) {
1940                                 AssertEquals("#N31", typeof(FormatException), e.GetType());
1941                         }
1942
1943                         try {
1944                                 Convert.ToSingle("11000000000000000000000000000000000000000000000", ci);
1945                                 Fail();
1946                         }
1947                         catch (Exception e) {
1948                                 AssertEquals("#N32", typeof(OverflowException), e.GetType());
1949                         }
1950                 }
1951
1952                 public void TestToString() {
1953
1954                         tryByte = 123;
1955                         AssertEquals("#O01", "False", Convert.ToString(boolFalse));
1956                         AssertEquals("#O02", "True", Convert.ToString(boolTrue));
1957                         AssertEquals("#O03", "123", Convert.ToString(tryByte));
1958                         AssertEquals("#O04", "a", Convert.ToString(tryChar));
1959                         AssertEquals("#O05", tryDT.ToString(), Convert.ToString(tryDT));
1960                         AssertEquals("#O06", tryDec.ToString(), Convert.ToString(tryDec));
1961                         AssertEquals("#O07", tryDbl.ToString(), Convert.ToString(tryDbl));
1962                         AssertEquals("#O08", "1234", Convert.ToString(tryInt16));
1963                         AssertEquals("#O09", "12345", Convert.ToString(tryInt32));
1964                         AssertEquals("#O10", "123456789012", Convert.ToString(tryInt64));
1965                         AssertEquals("#O11", "123", Convert.ToString(trySByte));
1966                         AssertEquals("#O12", tryFloat.ToString(), Convert.ToString(tryFloat));
1967                         AssertEquals("#O13", "foobar", Convert.ToString(tryStr));
1968                         AssertEquals("#O14", "34567", Convert.ToString(tryUI16));
1969                         AssertEquals("#O15", "567891234", Convert.ToString(tryUI32));
1970                         AssertEquals("#O16", "True", Convert.ToString(boolTrue, ci));
1971                         AssertEquals("#O17", "False", Convert.ToString(boolFalse, ci));
1972                         AssertEquals("#O18", "123", Convert.ToString(tryByte, ci));
1973                         AssertEquals("#O19", "1111011", Convert.ToString(tryByte, 2));
1974                         AssertEquals("#O20", "173", Convert.ToString(tryByte, 8));
1975                         AssertEquals("#O21", "123", Convert.ToString(tryByte, 10));
1976                         AssertEquals("#O22", "7b", Convert.ToString(tryByte, 16));
1977                         AssertEquals("#O23", "a", Convert.ToString(tryChar, ci));
1978                         AssertEquals("#O24", tryDT.ToString(ci), Convert.ToString(tryDT, ci));
1979                         AssertEquals("#O25", tryDec.ToString(ci), Convert.ToString(tryDec,ci));
1980                         AssertEquals("#O26", tryDbl.ToString(ci), Convert.ToString(tryDbl, ci));
1981                         AssertEquals("#O27", "1234", Convert.ToString(tryInt16, ci));
1982                         AssertEquals("#O28", "10011010010", Convert.ToString(tryInt16, 2));
1983                         AssertEquals("#O29", "2322", Convert.ToString(tryInt16, 8));
1984                         AssertEquals("#O30", "1234", Convert.ToString(tryInt16, 10));
1985                         AssertEquals("#O31", "4d2", Convert.ToString(tryInt16, 16));
1986                         AssertEquals("#O32", "12345", Convert.ToString(tryInt32, ci));
1987                         AssertEquals("#O33", "11000000111001", Convert.ToString(tryInt32, 2));
1988                         AssertEquals("#O34", "30071", Convert.ToString(tryInt32, 8));
1989                         AssertEquals("#O35", "12345", Convert.ToString(tryInt32, 10));
1990                         AssertEquals("#O36", "3039", Convert.ToString(tryInt32, 16));
1991                         AssertEquals("#O37", "123456789012", Convert.ToString(tryInt64, ci));
1992                         AssertEquals("#O38", "1110010111110100110010001101000010100",
1993                                 Convert.ToString(tryInt64, 2));
1994                         AssertEquals("#O39", "1627646215024", Convert.ToString(tryInt64, 8));
1995                         AssertEquals("#O40", "123456789012", Convert.ToString(tryInt64, 10));
1996                         AssertEquals("#O41", "1cbe991a14", Convert.ToString(tryInt64, 16));
1997                         AssertEquals("#O42", "123", Convert.ToString((trySByte), ci));
1998                         AssertEquals("#O43", tryFloat.ToString(ci), Convert.ToString((tryFloat), ci));
1999                         AssertEquals("#O44", "foobar", Convert.ToString((tryStr), ci));
2000                         AssertEquals("#O45", "34567", Convert.ToString((tryUI16), ci));
2001                         AssertEquals("#O46", "567891234", Convert.ToString((tryUI32), ci));
2002                         AssertEquals("#O47", "0", Convert.ToString(tryUI64));
2003                         AssertEquals("#O48", "0", Convert.ToString((tryUI64), ci));
2004
2005                         try {
2006                                 Convert.ToString(tryInt16, 5);
2007                                 Fail();
2008                         }
2009                         catch (Exception e) {
2010                                 AssertEquals("#O55", typeof(ArgumentException), e.GetType());
2011                         }
2012
2013                         try {
2014                                 Convert.ToString(tryInt32, 17);
2015                                 Fail();
2016                         }
2017                         catch (Exception e) {
2018                                 AssertEquals("#O56", typeof(ArgumentException), e.GetType());
2019                         }
2020
2021                         try {
2022                                 Convert.ToString(tryInt64, 1);
2023                                 Fail();
2024                         }
2025                         catch (Exception e) {
2026                                 AssertEquals("#O57", typeof(ArgumentException), e.GetType());
2027                         }
2028                 }
2029
2030                 public void TestToUInt16() {
2031                         AssertEquals("#P01", (ushort)0, Convert.ToUInt16(boolFalse));
2032                         AssertEquals("#P02", (ushort)1, Convert.ToUInt16(boolTrue));
2033                         AssertEquals("#P03", (ushort)0, Convert.ToUInt16(tryByte));
2034                         AssertEquals("#P04", (ushort)97, Convert.ToUInt16(tryChar));
2035                         AssertEquals("#P05", (ushort)1234, Convert.ToUInt16(tryDec));
2036                         AssertEquals("#P06", (ushort)0, Convert.ToUInt16(tryDbl));
2037                         AssertEquals("#P07", (ushort)1234, Convert.ToUInt16(tryInt16));
2038                         AssertEquals("#P08", (ushort)12345, Convert.ToUInt16(tryInt32));
2039                         AssertEquals("#P09", (ushort)43752, Convert.ToUInt16((long)43752));
2040                         AssertEquals("#P10", (ushort)123, Convert.ToUInt16(trySByte));
2041                         AssertEquals("#P11", (ushort)1234, Convert.ToUInt16(tryFloat));
2042                         AssertEquals("#P12", (ushort)123, Convert.ToUInt16((string)"123"));
2043                         AssertEquals("#P13", (ushort)34567, Convert.ToUInt16(tryUI16));
2044                         AssertEquals("#P14", (ushort)56789, Convert.ToUInt16((uint)56789));
2045                         AssertEquals("#P15", (ushort)0, Convert.ToUInt16(tryUI64));
2046                         AssertEquals("#P16", (ushort)31, Convert.ToUInt16("31", ci));
2047                         AssertEquals("#P17", (ushort)14, Convert.ToUInt16("1110", 2));
2048                         AssertEquals("#P18", (ushort)32, Convert.ToUInt16("40", 8));
2049                         AssertEquals("#P19", (ushort)40, Convert.ToUInt16("40", 10));
2050                         AssertEquals("#P20", (ushort)64, Convert.ToUInt16("40", 16));
2051
2052
2053                         try {
2054                                 Convert.ToUInt16(tryDT);
2055                                 Fail();
2056                         }
2057                         catch (Exception e) {
2058                                 AssertEquals("#P25", typeof(InvalidCastException), e.GetType());
2059                         }
2060
2061                         try {
2062                                 Convert.ToUInt16(decimal.MaxValue);
2063                                 Fail();
2064                         }
2065                         catch (Exception e) {
2066                                 AssertEquals("#P26", typeof(OverflowException), e.GetType());
2067                         }
2068
2069                         try {
2070                                 Convert.ToUInt16(decimal.MinValue);
2071                                 Fail();
2072                         }
2073                         catch (Exception e) {
2074                                 AssertEquals("#P27", typeof(OverflowException), e.GetType());
2075                         }
2076
2077                         try {
2078                                 Convert.ToUInt16(double.MaxValue);
2079                                 Fail();
2080                         }
2081                         catch (Exception e) {
2082                                 AssertEquals("#P28", typeof(OverflowException), e.GetType());
2083                         }
2084
2085                         try {
2086                                 Convert.ToUInt16(double.MinValue);
2087                                 Fail();
2088                         }
2089                         catch (Exception e) {
2090                                 AssertEquals("#P29", typeof(OverflowException), e.GetType());
2091                         }
2092
2093                         try {
2094                                 Convert.ToUInt16(short.MinValue);
2095                                 Fail();
2096                         }
2097                         catch (Exception e) {
2098                                 AssertEquals("#P30", typeof(OverflowException), e.GetType());
2099                         }
2100
2101                         try {
2102                                 Convert.ToUInt16(int.MaxValue);
2103                                 Fail();
2104                         }
2105                         catch (Exception e) {
2106                                 AssertEquals("#P31", typeof(OverflowException), e.GetType());
2107                         }
2108
2109                         try {
2110                                 Convert.ToUInt16(int.MinValue);
2111                                 Fail();
2112                         }
2113                         catch (Exception e) {
2114                                 AssertEquals("#P32", typeof(OverflowException), e.GetType());
2115                         }
2116
2117                         try {
2118                                 Convert.ToUInt16(long.MaxValue);
2119                                 Fail();
2120                         }
2121                         catch (Exception e) {
2122                                 AssertEquals("#P33", typeof(OverflowException), e.GetType());
2123                         }
2124
2125                         try {
2126                                 Convert.ToUInt16(long.MinValue);
2127                                 Fail();
2128                         }
2129                         catch (Exception e) {
2130                                 AssertEquals("#P34", typeof(OverflowException), e.GetType());
2131                         }
2132
2133                         try {
2134                                 Convert.ToUInt16(tryObj);
2135                                 Fail();
2136                         }
2137                         catch (Exception e) {
2138                                 AssertEquals("#P35", typeof(InvalidCastException), e.GetType());
2139                         }
2140
2141                         try {
2142                                 Convert.ToUInt16(sbyte.MinValue);
2143                                 Fail();
2144                         }
2145                         catch (Exception e) {
2146                                 AssertEquals("#P36", typeof(OverflowException), e.GetType());
2147                         }
2148
2149                         try {
2150                                 Convert.ToUInt16(float.MaxValue);
2151                                 Fail();
2152                         }
2153                         catch (Exception e) {
2154                                 AssertEquals("#P37", typeof(OverflowException), e.GetType());
2155                         }
2156
2157                         try {
2158                                 Convert.ToUInt16(float.MinValue);
2159                                 Fail();
2160                         }
2161                         catch (Exception e) {
2162                                 AssertEquals("#P38", typeof(OverflowException), e.GetType());
2163                         }
2164
2165                         try {
2166                                 Convert.ToUInt16("1A2");
2167                                 Fail();
2168                         }
2169                         catch (Exception e) {
2170                                 AssertEquals("#P39", typeof(FormatException), e.GetType());
2171                         }
2172
2173                         try {
2174                                 Convert.ToUInt16("-32800");
2175                                 Fail();
2176                         }
2177                         catch (Exception e) {
2178                                 AssertEquals("#P40", typeof(OverflowException), e.GetType());
2179                         }
2180
2181                         try {
2182                                 Convert.ToUInt16(int.MaxValue.ToString());
2183                                 Fail();
2184                         }
2185                         catch (Exception e) {
2186                                 AssertEquals("#P41", typeof(OverflowException), e.GetType());
2187                         }
2188
2189                         try {
2190                                 Convert.ToUInt16(ulong.MaxValue);
2191                                 Fail();
2192                         }
2193                         catch (Exception e) {
2194                                 AssertEquals("#P42", typeof(OverflowException), e.GetType());
2195                         }
2196
2197                         try {
2198                                 Convert.ToUInt16("1A2", ci);
2199                                 Fail();
2200                         }
2201                         catch (Exception e) {
2202                                 AssertEquals("#P43", typeof(FormatException), e.GetType());
2203                         }
2204
2205                         try {
2206                                 Convert.ToUInt16("-32800", ci);
2207                                 Fail();
2208                         }
2209                         catch (Exception e) {
2210                                 AssertEquals("#P44", typeof(OverflowException), e.GetType());
2211                         }
2212
2213                         try {
2214                                 Convert.ToUInt16("456987", ci);
2215                                 Fail();
2216                         }
2217                         catch (Exception e) {
2218                                 AssertEquals("#P45", typeof(OverflowException), e.GetType());
2219                         }
2220
2221                         try {
2222                                 Convert.ToUInt16("40", 9);
2223                                 Fail();
2224                         }
2225                         catch (Exception e) {
2226                                 AssertEquals("#P46", typeof(ArgumentException), e.GetType());
2227                         }
2228
2229                         try {
2230                                 Convert.ToUInt16 ("abcde", 16);
2231                                 Fail ();
2232                         }
2233                         catch (Exception e) {
2234                                 AssertEquals ("#P47", typeof (OverflowException), e.GetType ());
2235                         }
2236                 }
2237
2238                 public void TestSignedToInt() {
2239                   //  String cannot contain a minus sign if the base is not 10.
2240                   // But can if it is ten, and + is allowed everywhere.
2241                   AssertEquals("Signed0", -1, Convert.ToInt32 ("-1", 10));
2242                   AssertEquals("Signed1", 1, Convert.ToInt32 ("+1", 10));
2243                   AssertEquals("Signed2", 1, Convert.ToInt32 ("+1", 2));
2244                   AssertEquals("Signed3", 1, Convert.ToInt32 ("+1", 8));
2245                   AssertEquals("Signed4", 1, Convert.ToInt32 ("+1", 16));
2246
2247                   try {
2248                         Convert.ToInt32("-1", 2);
2249                         Fail();
2250                   }
2251                   catch (Exception) {
2252                   }
2253                   try {
2254                         Convert.ToInt32("-1", 8);
2255                         Fail();
2256                   }
2257                   catch (Exception) {
2258                   }
2259                   try {
2260                         Convert.ToInt32("-1", 16);
2261                         Fail();
2262                   }
2263                   catch (Exception) {
2264                   }
2265
2266
2267                 }
2268
2269                 public void TestToUInt32() {
2270                         AssertEquals("#Q01", (uint)1, Convert.ToUInt32(boolTrue));
2271                         AssertEquals("#Q02", (uint)0, Convert.ToUInt32(boolFalse));
2272                         AssertEquals("#Q03", (uint)0, Convert.ToUInt32(tryByte));
2273                         AssertEquals("#Q04", (uint)97, Convert.ToUInt32(tryChar));
2274                         AssertEquals("#Q05", (uint)1234, Convert.ToUInt32(tryDec));
2275                         AssertEquals("#Q06", (uint)0, Convert.ToUInt32(tryDbl));
2276                         AssertEquals("#Q07", (uint)1234, Convert.ToUInt32(tryInt16));
2277                         AssertEquals("#Q08", (uint)12345, Convert.ToUInt32(tryInt32));
2278                         AssertEquals("#Q09", (uint)1234567890, Convert.ToUInt32((long)1234567890));
2279                         AssertEquals("#Q10", (uint)123, Convert.ToUInt32(trySByte));
2280                         AssertEquals("#Q11", (uint)1234, Convert.ToUInt32(tryFloat));
2281                         AssertEquals("#Q12", (uint)3456789, Convert.ToUInt32("3456789"));
2282                         AssertEquals("#Q13", (uint)34567, Convert.ToUInt32(tryUI16));
2283                         AssertEquals("#Q14", (uint)567891234, Convert.ToUInt32(tryUI32));
2284                         AssertEquals("#Q15", (uint)0, Convert.ToUInt32(tryUI64));
2285                         AssertEquals("#Q16", (uint)415, Convert.ToUInt32("110011111", 2));
2286                         AssertEquals("#Q17", (uint)156, Convert.ToUInt32("234" ,8));
2287                         AssertEquals("#Q18", (uint)234, Convert.ToUInt32("234" ,10));
2288                         AssertEquals("#Q19", (uint)564, Convert.ToUInt32("234" ,16));
2289
2290
2291                         try {
2292                                 Convert.ToUInt32(tryDT);
2293                                 Fail();
2294                         }
2295                         catch (Exception e) {
2296                                 AssertEquals("#Q25", typeof(InvalidCastException), e.GetType());
2297                         }
2298
2299                         try {
2300                                 Convert.ToUInt32(decimal.MaxValue);
2301                                 Fail();
2302                         }
2303                         catch (Exception e) {
2304                                 AssertEquals("#Q26", typeof(OverflowException), e.GetType());
2305                         }
2306
2307                         try {
2308                                 Convert.ToUInt32((decimal)-150);
2309                                 Fail();
2310                         }
2311                         catch (Exception e) {
2312                                 AssertEquals("#Q27", typeof(OverflowException), e.GetType());
2313                         }
2314
2315                         try {
2316                                 Convert.ToUInt32(double.MaxValue);
2317                                 Fail();
2318                         }
2319                         catch (Exception e) {
2320                                 AssertEquals("#Q28", typeof(OverflowException), e.GetType());
2321                         }
2322
2323                         try {
2324                                 Convert.ToUInt32((double)-1);
2325                                 Fail();
2326                         }
2327                         catch (Exception e) {
2328                                 AssertEquals("#Q29", typeof(OverflowException), e.GetType());
2329                         }
2330
2331                         try {
2332                                 Convert.ToUInt32(short.MinValue);
2333                                 Fail();
2334                         }
2335                         catch (Exception e) {
2336                                 AssertEquals("#Q30", typeof(OverflowException), e.GetType());
2337                         }
2338
2339                         try {
2340                                 Convert.ToUInt32(int.MinValue);
2341                                 Fail();
2342                         }
2343                         catch (Exception e) {
2344                                 AssertEquals("#Q31", typeof(OverflowException), e.GetType());
2345                         }
2346
2347                         try {
2348                                 Convert.ToUInt32(long.MaxValue);
2349                                 Fail();
2350                         }
2351                         catch (Exception e) {
2352                                 AssertEquals("#Q32", typeof(OverflowException), e.GetType());
2353                         }
2354
2355                         try {
2356                                 Convert.ToUInt32((long)-50000);
2357                                 Fail();
2358                         }
2359                         catch (Exception e) {
2360                                 AssertEquals("#Q33", typeof(OverflowException), e.GetType());
2361                         }
2362
2363                         try {
2364                                 Convert.ToUInt32(new Exception());
2365                                 Fail();
2366                         }
2367                         catch (Exception e) {
2368                                 AssertEquals("#Q34", typeof(InvalidCastException), e.GetType());
2369                         }
2370
2371                         try {
2372                                 Convert.ToUInt32(sbyte.MinValue);
2373                                 Fail();
2374                         }
2375                         catch (Exception e) {
2376                                 AssertEquals("#Q35", typeof(OverflowException), e.GetType());
2377                         }
2378
2379                         try {
2380                                 Convert.ToUInt32(float.MaxValue);
2381                                 Fail();
2382                         }
2383                         catch (Exception e) {
2384                                 AssertEquals("#Q36", typeof(OverflowException), e.GetType());
2385                         }
2386
2387                         try {
2388                                 Convert.ToUInt32(float.MinValue);
2389                                 Fail();
2390                         }
2391                         catch (Exception e) {
2392                                 AssertEquals("#Q37", typeof(OverflowException), e.GetType());
2393                         }
2394
2395                         try {
2396                                 Convert.ToUInt32("45t54");
2397                                 Fail();
2398                         }
2399                         catch (Exception e) {
2400                                 AssertEquals("#Q38", typeof(FormatException), e.GetType());
2401                         }
2402
2403                         try {
2404                                 Convert.ToUInt32("-55");
2405                                 Fail();
2406                         }
2407                         catch (Exception e) {
2408                                 AssertEquals("#Q39", typeof(OverflowException), e.GetType());
2409                         }
2410
2411                         try {
2412                                 Convert.ToUInt32(ulong.MaxValue);
2413                                 Fail();
2414                         }
2415                         catch (Exception e) {
2416                                 AssertEquals("#Q40", typeof(OverflowException), e.GetType());
2417                         }
2418
2419                         try {
2420                                 Convert.ToUInt32(new Exception(), ci);
2421                                 Fail();
2422                         }
2423                         catch (Exception e) {
2424                                 AssertEquals("#Q41", typeof(InvalidCastException), e.GetType());
2425                         }
2426
2427                         try {
2428                                 Convert.ToUInt32(tryStr, ci);
2429                                 Fail();
2430                         }
2431                         catch (Exception e) {
2432                                 AssertEquals("#Q42", typeof(FormatException), e.GetType());
2433                         }
2434
2435                         try {
2436                                 Convert.ToUInt32("-50", ci);
2437                                 Fail();
2438                         }
2439                         catch (Exception e) {
2440                                 AssertEquals("#Q43", typeof(OverflowException), e.GetType());
2441                         }
2442
2443                         try {
2444                                 Convert.ToUInt32(decimal.MaxValue.ToString(), ci);
2445                                 Fail();
2446                         }
2447                         catch (Exception e) {
2448                                 AssertEquals("#Q44", typeof(OverflowException), e.GetType());
2449                         }
2450
2451                         try {
2452                                 Convert.ToUInt32("1001110", 1);
2453                                 Fail();
2454                         }
2455                         catch (Exception e) {
2456                                 AssertEquals("#Q45", typeof(ArgumentException), e.GetType());
2457                         }
2458                 }
2459
2460                 public void TestToUInt64()
2461                 {
2462                         int iTest = 1;
2463                         try {
2464                                 AssertEquals("#R01", (ulong)1, Convert.ToUInt64(boolTrue));
2465                                 iTest++;
2466                                 AssertEquals("#R02", (ulong)0, Convert.ToUInt64(boolFalse));
2467                                 iTest++;
2468                                 AssertEquals("#R03", (ulong)0, Convert.ToUInt64(tryByte));
2469                                 iTest++;
2470                                 AssertEquals("#R04", (ulong)97, Convert.ToUInt64(tryChar));
2471                                 iTest++;
2472                                 AssertEquals("#R05", (ulong)1234, Convert.ToUInt64(tryDec));
2473                                 iTest++;
2474                                 AssertEquals("#R06", (ulong)0, Convert.ToUInt64(tryDbl));
2475                                 iTest++;
2476                                 AssertEquals("#R07", (ulong)1234, Convert.ToUInt64(tryInt16));
2477                                 iTest++;
2478                                 AssertEquals("#R08", (ulong)12345, Convert.ToUInt64(tryInt32));
2479                                 iTest++;
2480                                 AssertEquals("#R09", (ulong)123456789012, Convert.ToUInt64(tryInt64));
2481                                 iTest++;
2482                                 AssertEquals("#R10", (ulong)123, Convert.ToUInt64(trySByte));
2483                                 iTest++;
2484                                 AssertEquals("#R11", (ulong)1234, Convert.ToUInt64(tryFloat));
2485                                 iTest++;
2486                                 AssertEquals("#R12", (ulong)345678, Convert.ToUInt64("345678"));
2487                                 iTest++;
2488                                 AssertEquals("#R13", (ulong)34567, Convert.ToUInt64(tryUI16));
2489                                 iTest++;
2490                                 AssertEquals("#R14", (ulong)567891234, Convert.ToUInt64(tryUI32));
2491                                 iTest++;
2492                                 AssertEquals("#R15", (ulong)0, Convert.ToUInt64(tryUI64));
2493                                 iTest++;
2494                                 AssertEquals("#R16", (ulong)123, Convert.ToUInt64("123", ci));
2495                                 iTest++;
2496                                 AssertEquals("#R17", (ulong)4, Convert.ToUInt64("100", 2));
2497                                 iTest++;
2498                                 AssertEquals("#R18", (ulong)64, Convert.ToUInt64("100", 8));
2499                                 iTest++;
2500                                 AssertEquals("#R19", (ulong)100, Convert.ToUInt64("100", 10));
2501                                 iTest++;
2502                                 AssertEquals("#R20", (ulong)256, Convert.ToUInt64("100", 16));
2503                         } catch (Exception e) {
2504                                 Fail ("Unexpected exception caught when iTest = " + iTest + ": e = " + e);
2505                         }
2506
2507                         try {
2508                                 Convert.ToUInt64(tryDT);
2509                                 Fail();
2510                         }
2511                         catch (Exception e) {
2512                                 AssertEquals("#R25", typeof(InvalidCastException), e.GetType());
2513                         }
2514
2515                         try {
2516                                 Convert.ToUInt64(decimal.MaxValue);
2517                                 Fail();
2518                         }
2519                         catch (Exception e) {
2520                                 AssertEquals("#R26", typeof(OverflowException), e.GetType());
2521                         }
2522
2523                         try {
2524                                 Convert.ToUInt64((decimal)-140);
2525                                 Fail();
2526                         }
2527                         catch (Exception e) {
2528                                 AssertEquals("#R27", typeof(OverflowException), e.GetType());
2529                         }
2530
2531                         try {
2532                                 Convert.ToUInt64(double.MaxValue);
2533                                 Fail();
2534                         }
2535                         catch (Exception e) {
2536                                 AssertEquals("#R28", typeof(OverflowException), e.GetType());
2537                         }
2538
2539                         try {
2540                                 Convert.ToUInt64((double)-1);
2541                                 Fail();
2542                         }
2543                         catch (Exception e) {
2544                                 AssertEquals("#R29", typeof(OverflowException), e.GetType());
2545                         }
2546
2547                         try {
2548                                 Convert.ToUInt64(short.MinValue);
2549                                 Fail();
2550                         }
2551                         catch (Exception e) {
2552                                 AssertEquals("#R30", typeof(OverflowException), e.GetType());
2553                         }
2554
2555                         try {
2556                                 Convert.ToUInt64(int.MinValue);
2557                                 Fail();
2558                         }
2559                         catch (Exception e) {
2560                                 AssertEquals("#R31", typeof(OverflowException), e.GetType());
2561                         }
2562
2563                         try {
2564                                 Convert.ToUInt64(long.MinValue);
2565                                 Fail();
2566                         }
2567                         catch (Exception e) {
2568                                 AssertEquals("#R32", typeof(OverflowException), e.GetType());
2569                         }
2570
2571                         try {
2572                                 Convert.ToUInt64(tryObj);
2573                                 Fail();
2574                         }
2575                         catch (Exception e) {
2576                                 AssertEquals("#R33", typeof(InvalidCastException), e.GetType());
2577                         }
2578
2579                         try {
2580                                 Convert.ToUInt64(sbyte.MinValue);
2581                                 Fail();
2582                         }
2583                         catch (Exception e) {
2584                                 AssertEquals("#R34", typeof(OverflowException), e.GetType());
2585                         }
2586
2587                         try {
2588                                 Convert.ToUInt64(float.MinValue);
2589                                 Fail();
2590                         }
2591                         catch (Exception e) {
2592                                 AssertEquals("#R35", typeof(OverflowException), e.GetType());
2593                         }
2594
2595                         try {
2596                                 Convert.ToUInt64(float.MaxValue);
2597                                 Fail();
2598                         }
2599                         catch (Exception e) {
2600                                 AssertEquals("#R36", typeof(OverflowException), e.GetType());
2601                         }
2602
2603                         try {
2604                                 Convert.ToUInt64("234rt78");
2605                                 Fail();
2606                         }
2607                         catch (Exception e) {
2608                                 AssertEquals("#R37", typeof(FormatException), e.GetType());
2609                         }
2610
2611                         try {
2612                                 Convert.ToUInt64("-68");
2613                                 Fail();
2614                         }
2615                         catch (Exception e) {
2616                                 AssertEquals("#R38", typeof(OverflowException), e.GetType());
2617                         }
2618
2619                         try {
2620                                 Convert.ToUInt64(decimal.MaxValue.ToString());
2621                                 Fail();
2622                         }
2623                         catch (Exception e) {
2624                                 AssertEquals("#R39", typeof(OverflowException), e.GetType());
2625                         }
2626
2627                         try {
2628                                 Convert.ToUInt64("23rd2", ci);
2629                                 Fail();
2630                         }
2631                         catch (Exception e) {
2632                                 AssertEquals("#R40", typeof(FormatException), e.GetType());
2633                         }
2634
2635                         try {
2636                                 Convert.ToUInt64(decimal.MinValue.ToString(), ci);
2637                                 Fail();
2638                         }
2639                         catch (Exception e) {
2640                                 AssertEquals("#R41", typeof(OverflowException), e.GetType());
2641                         }
2642
2643                         try {
2644                                 Convert.ToUInt64(decimal.MaxValue.ToString(), ci);
2645                                 Fail();
2646                         }
2647                         catch (Exception e) {
2648                                 AssertEquals("#R42", typeof(OverflowException), e.GetType());
2649                         }
2650
2651                         try {
2652                                 Convert.ToUInt64("132", 9);
2653                                 Fail();
2654                         }
2655                         catch (Exception e) {
2656                                 AssertEquals("#R43", typeof(ArgumentException), e.GetType());
2657                         }
2658                 }
2659
2660                 [Test]
2661                 [ExpectedException (typeof (FormatException))]
2662                 public void TestInvalidBase64() {
2663                   // This has to be a multiple of 4 characters, otherwise you
2664                   // are testing something else. Ideally one will become a byte
2665                   // > 128
2666                   //
2667                   // This test is designed to see what happens with invalid bytes
2668                   string brokenB64 = "AB~\u00a3";
2669                   Convert.FromBase64String(brokenB64);
2670                 }
2671
2672
2673                 public void TestToBase64CharArray ()
2674                 {
2675                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2676                         //                                                 0    1        2        3    4        5        6        7
2677                         char[] expectedCharArr = {'I', 'X', '/', '/', 'b', 'a', 'o', '2'};
2678                         char[] result = new Char[8];
2679
2680                         Convert.ToBase64CharArray(byteArr, 0, byteArr.Length, result, 0);
2681
2682                         for (int i = 0; i < expectedCharArr.Length; i++) {
2683                                 AssertEquals("#S0" + i, expectedCharArr[i], result[i]);
2684                         }
2685                 }
2686
2687                 [Test]
2688                 [ExpectedException (typeof(ArgumentNullException))]
2689                 public void ToBase64CharArray_InNull ()
2690                 {
2691                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2692                         char[] result = new Char[8];
2693                         Convert.ToBase64CharArray (null, 0, byteArr.Length, result, 0);
2694                 }
2695
2696                 [Test]
2697                 [ExpectedException (typeof(ArgumentNullException))]
2698                 public void ToBase64CharArray_OutNull ()
2699                 {
2700                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2701                         Convert.ToBase64CharArray (byteArr, 0, byteArr.Length, null, 0);
2702                 }
2703
2704                 [Test]
2705                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2706                 public void ToBase64CharArray_OffsetInNegative ()
2707                 {
2708                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2709                         char[] result = new Char[8];
2710                         Convert.ToBase64CharArray (byteArr, -1, byteArr.Length, result, 0);
2711                 }
2712
2713                 [Test]
2714                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2715                 public void ToBase64CharArray_LengthNegative ()
2716                 {
2717                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2718                         char[] result = new Char[8];
2719                         Convert.ToBase64CharArray (byteArr, 0, -5, result, 0);
2720                 }
2721
2722                 [Test]
2723                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2724                 public void ToBase64CharArray_OffsetOutNegative ()
2725                 {
2726                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2727                         char[] result = new Char[8];
2728                         Convert.ToBase64CharArray (byteArr, 0, byteArr.Length, result, -2);
2729                 }
2730
2731                 [Test]
2732                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2733                 public void ToBase64CharArray_TotalIn ()
2734                 {
2735                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2736                         char[] result = new Char[8];
2737                         Convert.ToBase64CharArray (byteArr, 4, byteArr.Length, result, 0);
2738                 }
2739
2740                 [Test]
2741                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2742                 public void ToBase64CharArray_TotalInOverflow ()
2743                 {
2744                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2745                         char[] result = new Char[8];
2746                         Convert.ToBase64CharArray (byteArr, Int32.MaxValue, byteArr.Length, result, 0);
2747                 }
2748
2749                 [Test]
2750                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2751                 public void ToBase64CharArray_TotalOut ()
2752                 {
2753                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2754                         char[] result = new Char[8];
2755                         Convert.ToBase64CharArray (byteArr, 0, byteArr.Length, result, 2);
2756                 }
2757
2758                 [Test]
2759                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2760                 public void ToBase64CharArray_TotalOutOverflow ()
2761                 {
2762                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2763                         char[] result = new Char[8];
2764                         Convert.ToBase64CharArray (byteArr, 0, byteArr.Length, result, Int32.MaxValue);
2765                 }
2766
2767                 public void TestToBase64String() {
2768                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2769                         string expectedStr = "IX//bao2";
2770                         string result1;
2771                         string result2;
2772
2773                         result1 = Convert.ToBase64String(byteArr);
2774                         result2 = Convert.ToBase64String(byteArr, 0, byteArr.Length);
2775
2776                         AssertEquals("#T01", expectedStr, result1);
2777                         AssertEquals("#T02", expectedStr, result2);
2778
2779                         try {
2780                                 Convert.ToBase64String(null);
2781                                 Fail();
2782                         }
2783                         catch (Exception e) {
2784                                 AssertEquals("#T05", typeof(ArgumentNullException), e.GetType());
2785                         }
2786
2787                         try {
2788                                 Convert.ToBase64String(byteArr, -1, byteArr.Length);
2789                                 Fail();
2790                         }
2791                         catch (Exception e) {
2792                                 AssertEquals("#T06", typeof(ArgumentOutOfRangeException), e.GetType());
2793                         }
2794
2795                         try {
2796                                 Convert.ToBase64String(byteArr, 0, -10);
2797                                 Fail();
2798                         }
2799                         catch (Exception e) {
2800                                 AssertEquals("#T07", typeof(ArgumentOutOfRangeException), e.GetType());
2801                         }
2802
2803                         try {
2804                                 Convert.ToBase64String(byteArr, 4, byteArr.Length);
2805                                 Fail();
2806                         }
2807                         catch (Exception e) {
2808                                 AssertEquals("#T08", typeof(ArgumentOutOfRangeException), e.GetType());
2809                         }
2810                 }
2811
2812                 /* Have experienced some problems with FromBase64CharArray using mono. Something
2813                  * about error in a unicode file.
2814                  *
2815                  * However the test seems to run fine using mono in a cygwin environment
2816                  */
2817
2818                 [Test]
2819                 [ExpectedException (typeof (ArgumentNullException))]
2820                 public void FromBase64CharArray_Null ()
2821                 {
2822                         Convert.FromBase64CharArray (null, 1, 5);
2823                 }
2824
2825                 [Test]
2826                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2827                 public void FromBase64CharArray_OutOfRangeStart ()
2828                 {
2829                         Convert.FromBase64CharArray (new char [4], -1, 4);
2830                 }
2831
2832                 [Test]
2833                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2834                 public void FromBase64CharArray_OutOfRangeLength ()
2835                 {
2836                         Convert.FromBase64CharArray (new char [4], 2, 4);
2837                 }
2838
2839                 [Test]
2840                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2841                 public void FromBase64CharArray_Overflow ()
2842                 {
2843                         Convert.FromBase64CharArray (new char [4], Int32.MaxValue, 4);
2844                 }
2845
2846                 [Test]
2847                 [ExpectedException (typeof (FormatException))]
2848                 public void FromBase64CharArray_InvalidLength ()
2849                 {
2850                         Convert.FromBase64CharArray (new char [4], 0, 3);
2851                 }
2852
2853                 [Test]
2854                 [ExpectedException (typeof (FormatException))]
2855                 public void FromBase64CharArray_WideChar ()
2856                 {
2857                         char[] c = new char [4] { 'A', 'A', 'A', (char) Char.MaxValue };
2858                         Convert.FromBase64CharArray (c, 0, 4);
2859                 }
2860
2861                 [Test]
2862                 public void FromBase64CharArray ()
2863                 {
2864                         char[] charArr = {'M','o','n','o','m','o','n','o'};
2865                         byte[] expectedByteArr = {50, 137, 232, 154, 137, 232};
2866
2867                         byte[] fromCharArr = Convert.FromBase64CharArray(charArr, 0, 8);
2868
2869                         for (int i = 0; i < fromCharArr.Length; i++){
2870                                 AssertEquals("#U0" + i, expectedByteArr[i], fromCharArr[i]);
2871                         }
2872                 }
2873
2874                 /* Have experienced some problems with FromBase64String using mono. Something about
2875                  * error in a unicode file.
2876                  *
2877                  * However the test seems to run fine using mono in a cygwin environment
2878                  */
2879
2880                 [Test]
2881                 [ExpectedException (typeof (ArgumentNullException))]
2882                 public void FromBase64String_Null ()
2883                 {
2884                         Convert.FromBase64String (null);
2885                 }
2886
2887                 [Test]
2888                 [ExpectedException (typeof (FormatException))]
2889                 public void FromBase64String_InvalidLength ()
2890                 {
2891                         Convert.FromBase64String ("foo");
2892                 }
2893
2894                 [Test]
2895                 [ExpectedException (typeof (FormatException))]
2896                 public void FromBase64String_InvalidLength2 ()
2897                 {
2898                         Convert.FromBase64String (tryStr);
2899                 }
2900
2901                 [Test]
2902                 public void FromBase64String_InvalidLengthBecauseOfIgnoredChars ()
2903                 {
2904                         byte[] result = Convert.FromBase64String ("AAAA\t");
2905                         AssertEquals ("InvalidLengthBecauseOfIgnoredChars", 3, result.Length);
2906                 }
2907
2908                 private const string ignored = "\t\r\n ";
2909                 private const string base64data = "AAAAAAAAAAAAAAAAAAAA"; // 15 bytes 0x00
2910
2911                 [Test]
2912                 public void FromBase64_IgnoreCharsBefore ()
2913                 {
2914                         string s = ignored + base64data;
2915                         byte[] data = Convert.FromBase64String (s);
2916                         AssertEquals ("String-IgnoreCharsBefore-Ignored", 15, data.Length);
2917
2918                         char[] c = s.ToCharArray ();
2919                         data = Convert.FromBase64CharArray (c, 0, c.Length);
2920                         AssertEquals ("CharArray-IgnoreCharsBefore-Ignored", 15, data.Length);
2921                 }
2922
2923                 [Test]
2924                 public void FromBase64_IgnoreCharsInside ()
2925                 {
2926                         string s = base64data + ignored + base64data;
2927                         byte[] data = Convert.FromBase64String (s);
2928                         AssertEquals ("String-IgnoreCharsInside-Ignored", 30, data.Length);
2929
2930                         char[] c = s.ToCharArray ();
2931                         data = Convert.FromBase64CharArray (c, 0, c.Length);
2932                         AssertEquals ("CharArray-IgnoreCharsInside-Ignored", 30, data.Length);
2933                 }
2934
2935                 [Test]
2936                 public void FromBase64_IgnoreCharsAfter ()
2937                 {
2938                         string s = base64data + ignored;
2939                         byte[] data = Convert.FromBase64String (s);
2940                         AssertEquals ("String-IgnoreCharsAfter-Ignored", 15, data.Length);
2941
2942                         char[] c = s.ToCharArray ();
2943                         data = Convert.FromBase64CharArray (c, 0, c.Length);
2944                         AssertEquals ("CharArray-IgnoreCharsAfter-Ignored", 15, data.Length);
2945                 }
2946
2947                                 public void TestConvertFromNull() {
2948
2949                                         AssertEquals ("#W1", false, Convert.ToBoolean (null as object));
2950                                         AssertEquals ("#W2", 0, Convert.ToByte (null as object));
2951                                         AssertEquals ("#W3", 0, Convert.ToChar (null as object));
2952                                         AssertEquals ("#W4", new DateTime (1,1,1,0,0,0), Convert.ToDateTime (null as object));
2953                                         AssertEquals ("#W5", 0, Convert.ToDecimal (null as object));
2954                                         AssertEquals ("#W6", 0, Convert.ToDouble (null as object));
2955                                         AssertEquals ("#W7", 0, Convert.ToInt16 (null as object));
2956                                         AssertEquals ("#W8", 0, Convert.ToInt32 (null as object));
2957                                         AssertEquals ("#W9", 0, Convert.ToInt64 (null as object));
2958                                         AssertEquals ("#W10", 0, Convert.ToSByte (null as object));
2959                                         AssertEquals ("#W11", 0, Convert.ToSingle (null as object));
2960                                         AssertEquals ("#W12", "", Convert.ToString (null as object));
2961                                         AssertEquals ("#W13", 0, Convert.ToUInt16 (null as object));
2962                                         AssertEquals ("#W14", 0, Convert.ToUInt32 (null as object));
2963                                         AssertEquals ("#W15", 0, Convert.ToUInt64 (null as object));
2964                                         AssertEquals ("#W16", false, Convert.ToBoolean (null as string));
2965                                         AssertEquals ("#W17", 0, Convert.ToByte (null as string));
2966
2967                                         try {
2968                                                 Convert.ToChar (null as string);
2969                                                 Fail ();
2970                                         } catch (Exception e) {
2971                                                 AssertEquals ("#W18", typeof (ArgumentNullException), e.GetType ());
2972                                         }
2973
2974                                         AssertEquals ("#W19", new DateTime (1,1,1,0,0,0), Convert.ToDateTime (null as string));
2975                                         AssertEquals ("#W20", 0, Convert.ToDecimal (null as string));
2976                                         AssertEquals ("#W21", 0, Convert.ToDouble (null as string));
2977                                         AssertEquals ("#W22", 0, Convert.ToInt16 (null as string));
2978                                         AssertEquals ("#W23", 0, Convert.ToInt32 (null as string));
2979                                         AssertEquals ("#W24", 0, Convert.ToInt64 (null as string));
2980                                         AssertEquals ("#W25", 0, Convert.ToSByte (null as string));
2981                                         AssertEquals ("#W26", 0, Convert.ToSingle (null as string));
2982                                         AssertEquals ("#W27", null, Convert.ToString (null as string));
2983                                         AssertEquals ("#W28", 0, Convert.ToUInt16 (null as string));
2984                                         AssertEquals ("#W29", 0, Convert.ToUInt32 (null as string));
2985                                         AssertEquals ("#W30", 0, Convert.ToUInt64 (null as string));
2986                                 }
2987
2988                 [Test]
2989                 public void ToByte_PrefixedHexStringInBase16 ()
2990                 {
2991                         AssertEquals ("0xff", 255, Convert.ToByte ("0xff", 16));
2992                         AssertEquals ("0xfF", 255, Convert.ToByte ("0xfF", 16));
2993                         AssertEquals ("0xFf", 255, Convert.ToByte ("0xFf", 16));
2994                         AssertEquals ("0xFF", 255, Convert.ToByte ("0xFF", 16));
2995
2996                         AssertEquals ("0Xff", 255, Convert.ToByte ("0Xff", 16));
2997                         AssertEquals ("0XfF", 255, Convert.ToByte ("0XfF", 16));
2998                         AssertEquals ("0XFf", 255, Convert.ToByte ("0XFf", 16));
2999                         AssertEquals ("0XFF", 255, Convert.ToByte ("0XFF", 16));
3000
3001                         AssertEquals ("0x0", Byte.MinValue, Convert.ToByte ("0x0", 16));
3002                 }
3003
3004                 [Test]
3005                 [ExpectedException (typeof (FormatException))]
3006                 public void ToByte_BadHexPrefix ()
3007                 {
3008                         Convert.ToByte ("0x", 16);
3009                 }
3010
3011                 [Test]
3012                 [ExpectedException (typeof (OverflowException))]
3013                 public void ToByte_NegativeString ()
3014                 {
3015                         Convert.ToByte ("-1");
3016                 }
3017
3018                 [Test]
3019                 [ExpectedException (typeof (ArgumentException))]
3020                 public void ToByte_NegativeStringNonBase10 ()
3021                 {
3022                         Convert.ToByte ("-0", 16);
3023                 }
3024
3025                 [Test]
3026                 [ExpectedException (typeof (OverflowException))]
3027                 public void ToByte_NegativeString_Base10 ()
3028                 {
3029                         Convert.ToByte ("-0", 10);
3030                 }
3031
3032                 [Test]
3033                 public void ToByte_NegativeZeroString ()
3034                 {
3035                         Convert.ToByte ("-0");
3036                         Convert.ToByte ("-0", null);
3037                 }
3038
3039                 [Test]
3040                 [ExpectedException (typeof (OverflowException))]
3041                 public void ToUInt16_NegativeString ()
3042                 {
3043                         Convert.ToUInt16 ("-1");
3044                 }
3045
3046                 [Test]
3047                 [ExpectedException (typeof (ArgumentException))]
3048                 public void ToUInt16_NegativeStringNonBase10 ()
3049                 {
3050                         Convert.ToUInt16 ("-0", 16);
3051                 }
3052
3053                 [Test]
3054                 [ExpectedException (typeof (OverflowException))]
3055                 public void ToUInt16_NegativeString_Base10 ()
3056                 {
3057                         Convert.ToUInt16 ("-0", 10);
3058                 }
3059
3060                 [Test]
3061                 public void ToUInt16_NegativeZeroString ()
3062                 {
3063                         Convert.ToUInt16 ("-0");
3064                         Convert.ToUInt16 ("-0", null);
3065                 }
3066
3067                 [Test]
3068                 [ExpectedException (typeof (OverflowException))]
3069                 public void ToUInt32_NegativeString ()
3070                 {
3071                         Convert.ToUInt32 ("-1");
3072                 }
3073
3074                 [Test]
3075                 [ExpectedException (typeof (ArgumentException))]
3076                 public void ToUInt32_NegativeStringNonBase10 ()
3077                 {
3078                         Convert.ToUInt32 ("-0", 16);
3079                 }
3080
3081                 [Test]
3082                 [ExpectedException (typeof (OverflowException))]
3083                 public void ToUInt32_NegativeString_Base10 ()
3084                 {
3085                         Convert.ToUInt32 ("-0", 10);
3086                 }
3087
3088                 [Test]
3089                 public void ToUInt32_NegativeZeroString ()
3090                 {
3091                         Convert.ToUInt32 ("-0");
3092                         Convert.ToUInt32 ("-0", null);
3093                 }
3094
3095                 [Test]
3096                 [ExpectedException (typeof (OverflowException))]
3097                 public void ToUInt64_NegativeString ()
3098                 {
3099                         Convert.ToUInt64 ("-1");
3100                 }
3101
3102                 [Test]
3103                 [ExpectedException (typeof (ArgumentException))]
3104                 public void ToUInt64_NegativeStringNonBase10 ()
3105                 {
3106                         Convert.ToUInt64 ("-0", 16);
3107                 }
3108
3109                 [Test]
3110                 [ExpectedException (typeof (OverflowException))]
3111                 public void ToUInt64_NegativeString_Base10 ()
3112                 {
3113                         Convert.ToUInt64 ("-0", 10);
3114                 }
3115
3116                 [Test]
3117                 public void ToUInt64_NegativeZeroString ()
3118                 {
3119                         Convert.ToUInt64 ("-0");
3120                         Convert.ToUInt64 ("-0", null);
3121                 }
3122
3123                 // min/max unsigned
3124
3125                 [Test]
3126                 public void ToByte_MaxValue ()
3127                 {
3128                         AssertEquals ("ff,16", Byte.MaxValue, Convert.ToByte ("ff", 16));
3129                         AssertEquals ("255,10", Byte.MaxValue, Convert.ToByte ("255", 10));
3130                         AssertEquals ("377,8", Byte.MaxValue, Convert.ToByte ("377", 8));
3131                         AssertEquals ("11111111,2", Byte.MaxValue, Convert.ToByte ("11111111", 2));
3132                 }
3133
3134                 [Test]
3135                 public void ToByte_MinValue ()
3136                 {
3137                         AssertEquals ("0,16", Byte.MinValue, Convert.ToByte ("0", 16));
3138                         AssertEquals ("0,10", Byte.MinValue, Convert.ToByte ("0", 10));
3139                         AssertEquals ("0,8", Byte.MinValue, Convert.ToByte ("0", 8));
3140                         AssertEquals ("0,2", Byte.MinValue, Convert.ToByte ("0", 2));
3141                 }
3142
3143                 [Test]
3144                 public void ToUInt16_MaxValue ()
3145                 {
3146                         AssertEquals ("ffff,16", UInt16.MaxValue, Convert.ToUInt16 ("ffff", 16));
3147                         AssertEquals ("65535,10", UInt16.MaxValue, Convert.ToUInt16 ("65535", 10));
3148                         AssertEquals ("177777,8", UInt16.MaxValue, Convert.ToUInt16 ("177777", 8));
3149                         AssertEquals ("1111111111111111,2", UInt16.MaxValue, Convert.ToUInt16 ("1111111111111111", 2));
3150                 }
3151
3152                 [Test]
3153                 public void ToUInt16_MinValue ()
3154                 {
3155                         AssertEquals ("0,16", UInt16.MinValue, Convert.ToUInt16 ("0", 16));
3156                         AssertEquals ("0,10", UInt16.MinValue, Convert.ToUInt16 ("0", 10));
3157                         AssertEquals ("0,8", UInt16.MinValue, Convert.ToUInt16 ("0", 8));
3158                         AssertEquals ("0,2", UInt16.MinValue, Convert.ToUInt16 ("0", 2));
3159                 }
3160
3161                 [Test]
3162                 public void ToUInt32_MaxValue ()
3163                 {
3164                         AssertEquals ("ffffffff,16", UInt32.MaxValue, Convert.ToUInt32 ("ffffffff", 16));
3165                         AssertEquals ("4294967295,10", UInt32.MaxValue, Convert.ToUInt32 ("4294967295", 10));
3166                         AssertEquals ("37777777777,8", UInt32.MaxValue, Convert.ToUInt32 ("37777777777", 8));
3167                         AssertEquals ("11111111111111111111111111111111,2", UInt32.MaxValue, Convert.ToUInt32 ("11111111111111111111111111111111", 2));
3168                 }
3169
3170                 [Test]
3171                 public void ToUInt32_MinValue ()
3172                 {
3173                         AssertEquals ("0,16", UInt32.MinValue, Convert.ToUInt32 ("0", 16));
3174                         AssertEquals ("0,10", UInt32.MinValue, Convert.ToUInt32 ("0", 10));
3175                         AssertEquals ("0,8", UInt32.MinValue, Convert.ToUInt32 ("0", 8));
3176                         AssertEquals ("0,2", UInt32.MinValue, Convert.ToUInt32 ("0", 2));
3177                 }
3178
3179                 [Test]
3180                 public void ToUInt64_MaxValue ()
3181                 {
3182                         AssertEquals ("ffffffffffffffff,16", UInt64.MaxValue, Convert.ToUInt64 ("ffffffffffffffff", 16));
3183                         AssertEquals ("18446744073709551615,10", UInt64.MaxValue, Convert.ToUInt64 ("18446744073709551615", 10));
3184                         AssertEquals ("1777777777777777777777,8", UInt64.MaxValue, Convert.ToUInt64 ("1777777777777777777777", 8));
3185                         AssertEquals ("1111111111111111111111111111111111111111111111111111111111111111,2", UInt64.MaxValue, Convert.ToUInt64 ("1111111111111111111111111111111111111111111111111111111111111111", 2));
3186                 }
3187
3188                 [Test]
3189                 public void ToUInt64_MinValue ()
3190                 {
3191                         AssertEquals ("0,16", UInt64.MinValue, Convert.ToUInt64 ("0", 16));
3192                         AssertEquals ("0,10", UInt64.MinValue, Convert.ToUInt64 ("0", 10));
3193                         AssertEquals ("0,8", UInt64.MinValue, Convert.ToUInt64 ("0", 8));
3194                         AssertEquals ("0,2", UInt64.MinValue, Convert.ToUInt64 ("0", 2));
3195                 }
3196
3197                 // min/max signed
3198
3199                 [Test]
3200                 public void ToSByte_MaxValue ()
3201                 {
3202                         AssertEquals ("7F,16", SByte.MaxValue, Convert.ToSByte ("7f", 16));
3203                         AssertEquals ("127,10", SByte.MaxValue, Convert.ToSByte ("127", 10));
3204                         AssertEquals ("177,8", SByte.MaxValue, Convert.ToSByte ("177", 8));
3205                         AssertEquals ("1111111,2", SByte.MaxValue, Convert.ToSByte ("1111111", 2));
3206                 }
3207
3208                 [Test]
3209                 public void ToSByte_MinValue ()
3210                 {
3211                         AssertEquals ("80,16", SByte.MinValue, Convert.ToSByte ("80", 16));
3212                         AssertEquals ("-128,10", SByte.MinValue, Convert.ToSByte ("-128", 10));
3213                         AssertEquals ("200,8", SByte.MinValue, Convert.ToSByte ("200", 8));
3214                         AssertEquals ("10000000,2", SByte.MinValue, Convert.ToSByte ("10000000", 2));
3215                 }
3216
3217                 [Test]
3218                 public void ToInt16_MaxValue ()
3219                 {
3220                         AssertEquals ("7FFF,16", Int16.MaxValue, Convert.ToInt16 ("7fff", 16));
3221                         AssertEquals ("32767,10", Int16.MaxValue, Convert.ToInt16 ("32767", 10));
3222                         AssertEquals ("77777,8", Int16.MaxValue, Convert.ToInt16 ("77777", 8));
3223                         AssertEquals ("111111111111111,2", Int16.MaxValue, Convert.ToInt16 ("111111111111111", 2));
3224                 }
3225
3226                 [Test]
3227                 public void ToInt16_MinValue ()
3228                 {
3229                         AssertEquals ("8000,16", Int16.MinValue, Convert.ToInt16 ("8000", 16));
3230                         AssertEquals ("-32768,10", Int16.MinValue, Convert.ToInt16 ("-32768", 10));
3231                         AssertEquals ("100000,8", Int16.MinValue, Convert.ToInt16 ("100000", 8));
3232                         AssertEquals ("1000000000000000,2", Int16.MinValue, Convert.ToInt16 ("1000000000000000", 2));
3233                 }
3234
3235                 [Test]
3236                 public void ToInt32_MaxValue ()
3237                 {
3238                         AssertEquals ("7fffffff,16", Int32.MaxValue, Convert.ToInt32 ("7fffffff", 16));
3239                         AssertEquals ("2147483647,10", Int32.MaxValue, Convert.ToInt32 ("2147483647", 10));
3240                         AssertEquals ("17777777777,8", Int32.MaxValue, Convert.ToInt32 ("17777777777", 8));
3241                         AssertEquals ("1111111111111111111111111111111,2", Int32.MaxValue, Convert.ToInt32 ("1111111111111111111111111111111", 2));
3242                 }
3243
3244                 [Test]
3245                 public void ToInt32_MinValue ()
3246                 {
3247                         AssertEquals ("80000000,16", Int32.MinValue, Convert.ToInt32 ("80000000", 16));
3248                         AssertEquals ("-2147483648,10", Int32.MinValue, Convert.ToInt32 ("-2147483648", 10));
3249                         AssertEquals ("20000000000,8", Int32.MinValue, Convert.ToInt32 ("20000000000", 8));
3250                         AssertEquals ("10000000000000000000000000000000,2", Int32.MinValue, Convert.ToInt32 ("10000000000000000000000000000000", 2));
3251                 }
3252
3253                 [Test]
3254                 public void ToInt64_MaxValue ()
3255                 {
3256                         AssertEquals ("7fffffffffffffff,16", Int64.MaxValue, Convert.ToInt64 ("7fffffffffffffff", 16));
3257                         AssertEquals ("9223372036854775807,10", Int64.MaxValue, Convert.ToInt64 ("9223372036854775807", 10));
3258                         AssertEquals ("777777777777777777777,8", Int64.MaxValue, Convert.ToInt64 ("777777777777777777777", 8));
3259                         AssertEquals ("111111111111111111111111111111111111111111111111111111111111111,2", Int64.MaxValue, Convert.ToInt64 ("111111111111111111111111111111111111111111111111111111111111111", 2));
3260                 }
3261
3262                 [Test]
3263                 public void ToInt64_MinValue ()
3264                 {
3265                         AssertEquals ("8000000000000000,16", Int64.MinValue, Convert.ToInt64 ("8000000000000000", 16));
3266                         AssertEquals ("-9223372036854775808,10", Int64.MinValue, Convert.ToInt64 ("-9223372036854775808", 10));
3267                         AssertEquals ("1000000000000000000000,8", Int64.MinValue, Convert.ToInt64 ("1000000000000000000000", 8));
3268                         AssertEquals ("1000000000000000000000000000000000000000000000000000000000000000,2", Int64.MinValue, Convert.ToInt64 ("1000000000000000000000000000000000000000000000000000000000000000", 2));
3269                 }
3270
3271                 // signed types
3272
3273                 [Test]
3274                 [ExpectedException (typeof (OverflowException))]
3275                 public void ToSByte_OverMaxValue ()
3276                 {
3277                         string max_plus1 = "128";
3278                         Convert.ToSByte (max_plus1);
3279                 }
3280
3281                 [Test]
3282                 [ExpectedException (typeof (OverflowException))]
3283                 public void ToSByte_OverMinValue ()
3284                 {
3285                         string min_minus1 = "-129";
3286                         Convert.ToSByte (min_minus1);
3287                 }
3288
3289                 [Test]
3290                 [ExpectedException (typeof (OverflowException))]
3291                 public void ToInt16_OverMaxValue ()
3292                 {
3293                         string max_plus1 = "32768";
3294                         Convert.ToInt16 (max_plus1);
3295                 }
3296
3297                 [Test]
3298                 [ExpectedException (typeof (OverflowException))]
3299                 public void ToInt16_OverMinValue ()
3300                 {
3301                         string min_minus1 = "-32769";
3302                         Convert.ToInt16 (min_minus1);
3303                 }
3304
3305                 [Test]
3306                 [ExpectedException (typeof (OverflowException))]
3307                 public void ToInt32_OverMaxValue ()
3308                 {
3309                         string max_plus1 = "2147483648";
3310                         Convert.ToInt32 (max_plus1);
3311                 }
3312
3313                 [Test]
3314                 [ExpectedException (typeof (OverflowException))]
3315                 public void ToInt32_OverMinValue ()
3316                 {
3317                         string min_minus1 = "-2147483649";
3318                         Convert.ToInt32 (min_minus1);
3319                 }
3320
3321                 [Test]
3322                 [ExpectedException (typeof (OverflowException))]
3323                 public void ToInt64_OverMaxValue ()
3324                 {
3325                         string max_plus1 = "9223372036854775808";
3326                         Convert.ToInt64 (max_plus1);
3327                 }
3328
3329                 [Test]
3330                 [ExpectedException (typeof (OverflowException))]
3331                 public void ToInt64_OverMinValue ()
3332                 {
3333                         string min_minus1 = "-9223372036854775809";
3334                         Convert.ToInt64 (min_minus1);
3335                 }
3336
3337                 // unsigned types
3338
3339                 [Test]
3340                 [ExpectedException (typeof (OverflowException))]
3341                 public void ToByte_OverMaxValue ()
3342                 {
3343                         string max_plus1 = "257";
3344                         Convert.ToByte (max_plus1);
3345                 }
3346
3347                 [Test]
3348                 [ExpectedException (typeof (OverflowException))]
3349                 public void ToByte_OverMinValue ()
3350                 {
3351                         string min_minus1 = "-1";
3352                         Convert.ToByte (min_minus1);
3353                 }
3354
3355                 [Test]
3356                 [ExpectedException (typeof (OverflowException))]
3357                 public void ToUInt16_OverMaxValue ()
3358                 {
3359                         string max_plus1 = "65536";
3360                         Convert.ToUInt16 (max_plus1);
3361                 }
3362
3363                 [Test]
3364                 [ExpectedException (typeof (OverflowException))]
3365                 public void ToUInt16_OverMinValue ()
3366                 {
3367                         string min_minus1 = "-1";
3368                         Convert.ToUInt16 (min_minus1);
3369                 }
3370
3371                 [Test]
3372                 [ExpectedException (typeof (OverflowException))]
3373                 public void ToUInt32_OverMaxValue ()
3374                 {
3375                         string max_plus1 = "4294967296";
3376                         Convert.ToUInt32 (max_plus1);
3377                 }
3378
3379                 [Test]
3380                 [ExpectedException (typeof (OverflowException))]
3381                 public void ToUInt32_OverMinValue ()
3382                 {
3383                         string min_minus1 = "-1";
3384                         Convert.ToUInt32 (min_minus1);
3385                 }
3386
3387                 [Test]
3388                 [ExpectedException (typeof (OverflowException))]
3389                 public void ToUInt64_OverMaxValue ()
3390                 {
3391                         string max_plus1 = "18446744073709551616";
3392                         Convert.ToUInt64 (max_plus1);
3393                 }
3394
3395                 [Test]
3396                 [ExpectedException (typeof (OverflowException))]
3397                 public void ToUInt64_OverMinValue ()
3398                 {
3399                         string min_minus1 = "-1";
3400                         Convert.ToUInt64 (min_minus1);
3401                 }
3402
3403                 [Test]
3404                 public void To_NullString ()
3405                 {
3406                         string s = null;
3407                         // signed
3408                         AssertEquals ("ToSByte", 0, Convert.ToSByte (s));
3409                         AssertEquals ("ToSByte+base", 0, Convert.ToSByte (s, 10));
3410                         AssertEquals ("ToInt16", 0, Convert.ToInt16 (s));
3411                         AssertEquals ("ToInt16+base", 0, Convert.ToInt16 (s, 10));
3412                         AssertEquals ("ToInt32", 0, Convert.ToInt32 (s));
3413                         AssertEquals ("ToInt32+base", 0, Convert.ToInt32 (s, 10));
3414                         AssertEquals ("ToInt64", 0, Convert.ToInt64 (s));
3415                         AssertEquals ("ToInt64+base", 0, Convert.ToInt64 (s, 10));
3416                         // unsigned
3417                         AssertEquals ("ToByte", 0, Convert.ToByte (s));
3418                         AssertEquals ("ToByte+base", 0, Convert.ToByte (s, 10));
3419                         AssertEquals ("ToUInt16", 0, Convert.ToUInt16 (s));
3420                         AssertEquals ("ToUInt16+base", 0, Convert.ToUInt16 (s, 10));
3421                         AssertEquals ("ToUInt32", 0, Convert.ToUInt32 (s));
3422                         AssertEquals ("ToUInt32+base", 0, Convert.ToUInt32 (s, 10));
3423                         AssertEquals ("ToUInt64", 0, Convert.ToUInt64 (s));
3424                         AssertEquals ("ToUInt64+base", 0, Convert.ToUInt64 (s, 10));
3425                 }
3426
3427                 [Test]
3428                 public void To_NullObject ()
3429                 {
3430                         object o = null;
3431                         // signed
3432                         AssertEquals ("ToSByte", 0, Convert.ToSByte (o));
3433                         AssertEquals ("ToInt16", 0, Convert.ToInt16 (o));
3434                         AssertEquals ("ToInt32", 0, Convert.ToInt32 (o));
3435                         AssertEquals ("ToInt64", 0, Convert.ToInt64 (o));
3436                         // unsigned
3437                         AssertEquals ("ToByte", 0, Convert.ToByte (o));
3438                         AssertEquals ("ToUInt16", 0, Convert.ToUInt16 (o));
3439                         AssertEquals ("ToUInt32", 0, Convert.ToUInt32 (o));
3440                         AssertEquals ("ToUInt64", 0, Convert.ToUInt64 (o));
3441                 }
3442
3443                 [Test]
3444                 public void To_NullObjectFormatProvider ()
3445                 {
3446                         object o = null;
3447                         IFormatProvider fp = (IFormatProvider) new NumberFormatInfo ();
3448                         // signed
3449                         AssertEquals ("ToSByte", 0, Convert.ToSByte (o, fp));
3450                         AssertEquals ("ToInt16", 0, Convert.ToInt16 (o, fp));
3451                         AssertEquals ("ToInt32", 0, Convert.ToInt32 (o, fp));
3452                         AssertEquals ("ToInt64", 0, Convert.ToInt64 (o, fp));
3453                         // unsigned
3454                         AssertEquals ("ToByte", 0, Convert.ToByte (o, fp));
3455                         AssertEquals ("ToUInt16", 0, Convert.ToUInt16 (o, fp));
3456                         AssertEquals ("ToUInt32", 0, Convert.ToUInt32 (o, fp));
3457                         AssertEquals ("ToUInt64", 0, Convert.ToUInt64 (o, fp));
3458                 }
3459
3460                 [Test]
3461                 [ExpectedException (typeof (ArgumentNullException))]
3462                 public void ToSByte_NullStringFormatProvider ()
3463                 {
3464                         string s = null;
3465                         // SByte is a "special" case ???
3466                         Convert.ToSByte (s, new NumberFormatInfo ());
3467                 }
3468
3469                 [Test]
3470                 public void To_NullStringFormatProvider ()
3471                 {
3472                         string s = null;
3473                         IFormatProvider fp = (IFormatProvider) new NumberFormatInfo ();
3474                         // signed
3475                         // No SByte here
3476                         AssertEquals ("ToInt16", 0, Convert.ToInt16 (s, fp));
3477                         AssertEquals ("ToInt32", 0, Convert.ToInt32 (s, fp));
3478                         AssertEquals ("ToInt64", 0, Convert.ToInt64 (s, fp));
3479                         // unsigned
3480                         AssertEquals ("ToByte", 0, Convert.ToByte (s, fp));
3481                         AssertEquals ("ToUInt16", 0, Convert.ToUInt16 (s, fp));
3482                         AssertEquals ("ToUInt32", 0, Convert.ToUInt32 (s, fp));
3483                         AssertEquals ("ToUInt64", 0, Convert.ToUInt64 (s, fp));
3484                 }
3485
3486                 [Test]
3487                 [ExpectedException (typeof (InvalidCastException))]
3488                 public void ChangeTypeToTypeCodeEmpty ()
3489                 {
3490                         Convert.ChangeType (true, TypeCode.Empty);
3491                 }
3492
3493                 [Test]
3494                 // 2005/01/10: The docs say this should throw an InvalidCastException,
3495                 // however, MS.NET 1.1 throws a NullReferenceException. Assuming docs
3496                 // are wrong.
3497 #if NET_2_0
3498                 [ExpectedException (typeof (InvalidCastException))]
3499 #else
3500                 [ExpectedException (typeof (NullReferenceException))]
3501 #endif
3502                 public void ChangeTypeNullToValuetype ()
3503                 {
3504                         Convert.ChangeType (null, typeof (int));
3505                 }
3506
3507                 [Test]
3508                 public void ToString_MinMax_WithBase ()
3509                 {
3510                         AssertEquals ("Byte.MinValue base 2",  "0", Convert.ToString (Byte.MinValue, 2));
3511                         AssertEquals ("Byte.MinValue base 8",  "0", Convert.ToString (Byte.MinValue, 8));
3512                         AssertEquals ("Byte.MinValue base 10", "0", Convert.ToString (Byte.MinValue, 10));
3513                         AssertEquals ("Byte.MinValue base 16", "0", Convert.ToString (Byte.MinValue, 16));
3514
3515                         AssertEquals ("Byte.MaxValue base 2",  "11111111", Convert.ToString (Byte.MaxValue, 2));
3516                         AssertEquals ("Byte.MaxValue base 8",  "377", Convert.ToString (Byte.MaxValue, 8));
3517                         AssertEquals ("Byte.MaxValue base 10", "255", Convert.ToString (Byte.MaxValue, 10));
3518                         AssertEquals ("Byte.MaxValue base 16", "ff", Convert.ToString (Byte.MaxValue, 16));
3519
3520                         AssertEquals ("Int16.MinValue base 2",  "1000000000000000", Convert.ToString (Int16.MinValue, 2));
3521                         AssertEquals ("Int16.MinValue base 8",  "100000", Convert.ToString (Int16.MinValue, 8));
3522                         AssertEquals ("Int16.MinValue base 10", "-32768", Convert.ToString (Int16.MinValue, 10));
3523                         AssertEquals ("Int16.MinValue base 16", "8000", Convert.ToString (Int16.MinValue, 16));
3524
3525                         AssertEquals ("Int16.MaxValue base 2",  "111111111111111", Convert.ToString (Int16.MaxValue, 2));
3526                         AssertEquals ("Int16.MaxValue base 8",  "77777", Convert.ToString (Int16.MaxValue, 8));
3527                         AssertEquals ("Int16.MaxValue base 10", "32767", Convert.ToString (Int16.MaxValue, 10));
3528                         AssertEquals ("Int16.MaxValue base 16", "7fff", Convert.ToString (Int16.MaxValue, 16));
3529
3530                         AssertEquals ("Int32.MinValue base 2",  "10000000000000000000000000000000", Convert.ToString (Int32.MinValue, 2));
3531                         AssertEquals ("Int32.MinValue base 8",  "20000000000", Convert.ToString (Int32.MinValue, 8));
3532                         AssertEquals ("Int32.MinValue base 10", "-2147483648", Convert.ToString (Int32.MinValue, 10));
3533                         AssertEquals ("Int32.MinValue base 16", "80000000", Convert.ToString (Int32.MinValue, 16));
3534
3535                         AssertEquals ("Int32.MaxValue base 2",  "1111111111111111111111111111111", Convert.ToString (Int32.MaxValue, 2));
3536                         AssertEquals ("Int32.MaxValue base 8",  "17777777777", Convert.ToString (Int32.MaxValue, 8));
3537                         AssertEquals ("Int32.MaxValue base 10", "2147483647", Convert.ToString (Int32.MaxValue, 10));
3538                         AssertEquals ("Int32.MaxValue base 16", "7fffffff", Convert.ToString (Int32.MaxValue, 16));
3539
3540                         AssertEquals ("Int64.MinValue base 2",  "1000000000000000000000000000000000000000000000000000000000000000", Convert.ToString (Int64.MinValue, 2));
3541                         AssertEquals ("Int64.MinValue base 8",  "1000000000000000000000", Convert.ToString (Int64.MinValue, 8));
3542                         AssertEquals ("Int64.MinValue base 10", "-9223372036854775808", Convert.ToString (Int64.MinValue, 10));
3543                         AssertEquals ("Int64.MinValue base 16", "8000000000000000", Convert.ToString (Int64.MinValue, 16));
3544
3545                         AssertEquals ("Int64.MaxValue base 2",  "111111111111111111111111111111111111111111111111111111111111111", Convert.ToString (Int64.MaxValue, 2));
3546                         AssertEquals ("Int64.MaxValue base 8",  "777777777777777777777", Convert.ToString (Int64.MaxValue, 8));
3547                         AssertEquals ("Int64.MaxValue base 10", "9223372036854775807", Convert.ToString (Int64.MaxValue, 10));
3548                         AssertEquals ("Int64.MaxValue base 16", "7fffffffffffffff", Convert.ToString (Int64.MaxValue, 16));
3549                 }
3550         }
3551 }