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 {
  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                                 Assert.AreEqual ((short)12345, Convert.ChangeType(tryInt32, typeof(short)), "#A01");
  71                                 iTest++;
  72                                 Assert.AreEqual ('A', Convert.ChangeType(65, typeof(char)), "#A02");
  73                                 iTest++;
  74                                 Assert.AreEqual (66, Convert.ChangeType('B', typeof(int)), "#A03");
  75                                 iTest++;
  76                                 Assert.AreEqual (((ulong)12345), Convert.ChangeType(tryInt32, typeof(ulong)), "#A04");
  77
  78                                 iTest++;
  79                                 Assert.AreEqual (true, Convert.ChangeType(tryDec, TypeCode.Boolean), "#A05");
  80                                 iTest++;
  81                                 Assert.AreEqual ('f', Convert.ChangeType("f", TypeCode.Char), "#A06");
  82                                 iTest++;
  83                                 Assert.AreEqual ((decimal)123456789012, Convert.ChangeType(tryInt64, TypeCode.Decimal), "#A07");
  84                                 iTest++;
  85                                 Assert.AreEqual ((int)34567, Convert.ChangeType(tryUI16, TypeCode.Int32), "#A08");
  86
  87                                 iTest++;
  88                                 Assert.AreEqual ((double)567891234, Convert.ChangeType(tryUI32, typeof(double), ci), "#A09");
  89                                 iTest++;
  90                                 Assert.AreEqual ((ushort)0, Convert.ChangeType(tryByte, typeof(ushort), ci), "#A10");
  91                                 iTest++;
  92                                 Assert.AreEqual ((decimal)567891234, Convert.ChangeType(tryUI32, typeof(decimal), ci), "#A11");
  93                                 iTest++;
  94                                 Assert.AreEqual ((float)1234, Convert.ChangeType(tryInt16, typeof(float), ci), "#A12");
  95                                 iTest++;
  96                                 Assert.AreEqual (null, Convert.ChangeType(null, null, ci), "#A13");
  97
  98                                 iTest++;
  99                                 Assert.AreEqual ((decimal)0, Convert.ChangeType(tryByte, TypeCode.Decimal, ci), "#A14");
 100                                 iTest++;
 101                                 Assert.AreEqual ("f", Convert.ChangeType('f', TypeCode.String, ci), "#A15");
 102                                 iTest++;
 103                                 Assert.AreEqual ('D', Convert.ChangeType(68, TypeCode.Char, ci), "#A16");
 104                                 iTest++;
 105                                 Assert.AreEqual ((long)34567, Convert.ChangeType(tryUI16, TypeCode.Int64, ci), "#A17");
 106                                 iTest++;
 107                                 Assert.AreEqual (null, Convert.ChangeType(null, TypeCode.Empty, ci), "#A18");
 108                         } catch (Exception e) {
 109                                 Assert.Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
 110                         }
 111
 112                         try {
 113                                 Convert.ChangeType(boolTrue, typeof(char));
 114                                 Assert.Fail ();
 115                         }
 116                         catch (Exception e) {
 117                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#A25");
 118                         }
 119
 120                         try {
 121                                 Convert.ChangeType(tryChar, typeof(DateTime));
 122                                 Assert.Fail ();
 123                         }
 124                         catch (Exception e) {
 125                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#A26");
 126                         }
 127
 128                         try {
 129                                 Convert.ChangeType(ci, TypeCode.String);
 130                                 Assert.Fail ();
 131                         }
 132                         catch (Exception e) {
 133                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#A27");
 134                         }
 135
 136                         try {
 137                                 Convert.ChangeType(tryInt32, null);
 138                                 Assert.Fail ();
 139                         }
 140                         catch (Exception e) {
 141                                 Assert.AreEqual (typeof(ArgumentNullException), e.GetType(), "#A28");
 142                         }
 143
 144                         try
 145                         {
 146                                 Convert.ChangeType(boolTrue, typeof(DateTime), ci);
 147                                 Assert.Fail ();
 148                         }
 149                         catch (Exception e) {
 150                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#A29");
 151                         }
 152
 153                         try {
 154                                 Convert.ChangeType(ci, typeof(DateTime), ci);
 155                                 Assert.Fail ();
 156                         }
 157                         catch (Exception e) {
 158                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#A30");
 159                         }
 160
 161                         /* Should throw ArgumentException but throws InvalidCastException
 162                         try {
 163                                 Convert.ChangeType(tryUI32, typeof(FormatException), ci);
 164                                 Assert.Fail ();
 165                         }
 166                         catch (Exception e) {
 167                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#A??");
 168                         }*/
 169
 170                         try {
 171                                 Convert.ChangeType(tryUI32, TypeCode.Byte, ci);
 172                                 Assert.Fail ();
 173                         }
 174                         catch (Exception e) {
 175                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#A31");
 176                         }
 177
 178                         try {
 179                                 Convert.ChangeType(boolTrue, TypeCode.Char, ci);
 180                                 Assert.Fail ();
 181                         }
 182                         catch (Exception e) {
 183                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#A32");
 184                         }
 185
 186                         try {
 187                                 Convert.ChangeType(boolTrue, null, ci);
 188                                 Assert.Fail ();
 189                         }
 190                         catch (Exception e) {
 191                                 Assert.AreEqual (typeof(ArgumentNullException), e.GetType(), "#A33");
 192                         }
 193
 194                         try {
 195                                 /* should fail to convert string to any enumeration type. */
 196                                 Convert.ChangeType("random string", typeof(DayOfWeek));
 197                                 Assert.Fail ();
 198                         }
 199                         catch (Exception e) {
 200                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#A34");
 201                         }
 202
 203                 }
 204
 205                 public void TestGetTypeCode() {
 206                         int marker = 1;
 207                         try {
 208                                 Assert.AreEqual (TypeCode.String, Convert.GetTypeCode(tryStr), "#B01");
 209                                 marker++;
 210                                 Assert.AreEqual (TypeCode.UInt16, Convert.GetTypeCode(tryUI16), "#B02");
 211                                 marker++;
 212                                 Assert.AreEqual (TypeCode.UInt32, Convert.GetTypeCode(tryUI32), "#B03");
 213                                 marker++;
 214                                 Assert.AreEqual (TypeCode.UInt64, Convert.GetTypeCode(tryUI64), "#B04");
 215                                 marker++;
 216                                 Assert.AreEqual (TypeCode.Double, Convert.GetTypeCode(tryDbl), "#B05");
 217                                 marker++;
 218                                 Assert.AreEqual (TypeCode.Int16, Convert.GetTypeCode(tryInt16), "#B06");
 219                                 marker++;
 220                                 Assert.AreEqual (TypeCode.Int64, Convert.GetTypeCode(tryInt64), "#B07");
 221                                 marker++;
 222                                 Assert.AreEqual (TypeCode.Object, Convert.GetTypeCode(tryObj), "#B08");
 223                                 marker++;
 224                                 Assert.AreEqual (TypeCode.SByte, Convert.GetTypeCode(trySByte), "#B09");
 225                                 marker++;
 226                                 Assert.AreEqual (TypeCode.Single, Convert.GetTypeCode(tryFloat), "#B10");
 227                                 marker++;
 228                                 Assert.AreEqual (TypeCode.Byte, Convert.GetTypeCode(tryByte), "#B11");
 229                                 marker++;
 230                                 Assert.AreEqual (TypeCode.Char, Convert.GetTypeCode(tryChar), "#B12");
 231                                 marker++;
 232 //                              Assert.AreEqual (TypeCode.DateTime, Convert.GetTypeCode(tryDT), "#B13");
 233                                 marker++;
 234                                 Assert.AreEqual (TypeCode.Decimal, Convert.GetTypeCode(tryDec), "#B14");
 235                                 marker++;
 236                                 Assert.AreEqual (TypeCode.Int32, Convert.GetTypeCode(tryInt32), "#B15");
 237                                 marker++;
 238                                 Assert.AreEqual (TypeCode.Boolean, Convert.GetTypeCode(boolTrue), "#B16");
 239                         } catch (Exception e) {
 240                                 Assert.Fail ("Unexpected exception at " + marker + ": " + e);
 241                         }
 242                 }
 243
 244                 public void TestIsDBNull() {
 245                         Assert.AreEqual (false, Convert.IsDBNull(tryInt32), "#C01");
 246                         Assert.AreEqual (true, Convert.IsDBNull(Convert.DBNull), "#C02");
 247                         Assert.AreEqual (false, Convert.IsDBNull(boolTrue), "#C03");
 248                         Assert.AreEqual (false, Convert.IsDBNull(tryChar), "#C04");
 249                         Assert.AreEqual (false, Convert.IsDBNull(tryFloat), "#C05");
 250                 }
 251
 252                 public void TestToBoolean() {
 253                         tryObj = (object)tryDbl;
 254
 255                         Assert.AreEqual (true, Convert.ToBoolean(boolTrue), "#D01");
 256                         Assert.AreEqual (false, Convert.ToBoolean(tryByte), "#D02");
 257                         Assert.AreEqual (true, Convert.ToBoolean(tryDec), "#D03");
 258                         Assert.AreEqual (false, Convert.ToBoolean(tryDbl), "#D04");
 259                         Assert.AreEqual (true, Convert.ToBoolean(tryInt16), "#D05");
 260                         Assert.AreEqual (true, Convert.ToBoolean(tryInt32), "#D06");
 261                         Assert.AreEqual (true, Convert.ToBoolean(tryInt64), "#D07");
 262                         Assert.AreEqual (false, Convert.ToBoolean(tryObj), "#D08");
 263                         Assert.AreEqual (true, Convert.ToBoolean(trySByte), "#D09");
 264                         Assert.AreEqual (true, Convert.ToBoolean(tryFloat), "#D10");
 265                         Assert.AreEqual (true, Convert.ToBoolean(trueString), "#D11");
 266                         Assert.AreEqual (false, Convert.ToBoolean(falseString), "#D12");
 267                         Assert.AreEqual (true, Convert.ToBoolean(tryUI16), "#D13");
 268                         Assert.AreEqual (true, Convert.ToBoolean(tryUI32), "#D14");
 269                         Assert.AreEqual (false, Convert.ToBoolean(tryUI64), "#D15");
 270                         Assert.AreEqual (false, Convert.ToBoolean(tryObj, ci), "#D16");
 271                         Assert.AreEqual (true, Convert.ToBoolean(trueString, ci), "#D17");
 272                         Assert.AreEqual (false, Convert.ToBoolean(falseString, ci), "#D18");
 273
 274                         try {
 275                                 Convert.ToBoolean(tryChar);
 276                                 Assert.Fail ();
 277                         }
 278                         catch (Exception e) {
 279                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#D20");
 280                         }
 281
 282                         try {
 283                                 Convert.ToBoolean(tryDT);
 284                                 Assert.Fail ();
 285                         }
 286                         catch (Exception e) {
 287                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#D21");
 288                         }
 289
 290                         try {
 291                                 Convert.ToBoolean(tryStr);
 292                                 Assert.Fail ();
 293                         }
 294                         catch (Exception e) {
 295                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#D22");
 296                         }
 297
 298                         try {
 299                                 Convert.ToBoolean(nullString);
 300                                 Assert.Fail ();
 301                         }
 302                         catch (Exception e) {
 303                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#D23");
 304                         }
 305                 }
 306
 307                 public void TestToByte() {
 308
 309                         Assert.AreEqual ((byte)1, Convert.ToByte(boolTrue), "#E01");
 310                         Assert.AreEqual ((byte)0, Convert.ToByte(boolFalse), "#E02");
 311                         Assert.AreEqual (tryByte, Convert.ToByte(tryByte), "#E03");
 312                         Assert.AreEqual ((byte)114, Convert.ToByte('r'), "#E04");
 313                         Assert.AreEqual ((byte)201, Convert.ToByte((decimal)200.6), "#E05");
 314                         Assert.AreEqual ((byte)125, Convert.ToByte((double)125.4), "#E06");
 315                         Assert.AreEqual ((byte)255, Convert.ToByte((short)255), "#E07");
 316                         Assert.AreEqual ((byte)254, Convert.ToByte((int)254), "#E08");
 317                         Assert.AreEqual ((byte)34, Convert.ToByte((long)34), "#E09");
 318                         Assert.AreEqual ((byte)1, Convert.ToByte((object)boolTrue), "#E10");
 319                         Assert.AreEqual ((byte)123, Convert.ToByte((float)123.49f), "#E11");
 320                         Assert.AreEqual ((byte)57, Convert.ToByte("57"), "#E12");
 321                         Assert.AreEqual ((byte)75, Convert.ToByte((ushort)75), "#E13");
 322                         Assert.AreEqual ((byte)184, Convert.ToByte((uint)184), "#E14");
 323                         Assert.AreEqual ((byte)241, Convert.ToByte((ulong)241), "#E15");
 324                         Assert.AreEqual ((byte)123, Convert.ToByte(trySByte, ci), "#E16");
 325                         Assert.AreEqual ((byte)27, Convert.ToByte("011011", 2), "#E17");
 326                         Assert.AreEqual ((byte)13, Convert.ToByte("15", 8), "#E18");
 327                         Assert.AreEqual ((byte)27, Convert.ToByte("27", 10), "#E19");
 328                         Assert.AreEqual ((byte)250, Convert.ToByte("FA", 16), "#E20");
 329
 330                         try {
 331                                 Convert.ToByte('\u03A9'); // sign of Omega on Win2k
 332                                 Assert.Fail ();
 333                         }
 334                         catch (Exception e) {
 335                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E25");
 336                         }
 337
 338                         try {
 339                                 Convert.ToByte(tryDT);
 340                                 Assert.Fail ();
 341                         }
 342                         catch (Exception e) {
 343                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#D26");
 344                         }
 345
 346                         try {
 347                                 Convert.ToByte((decimal)22000);
 348                                 Assert.Fail ();
 349                         }
 350                         catch (Exception e) {
 351                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E27");
 352                         }
 353
 354                         try {
 355                                 Convert.ToByte((double)255.5);
 356                                 Assert.Fail ();
 357                         }
 358                         catch (Exception e) {
 359                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E28");
 360                         }
 361
 362                         try {
 363                                 Convert.ToByte(-tryInt16);
 364                                 Assert.Fail ();
 365                         }
 366                         catch (Exception e) {
 367                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E29");
 368                         }
 369
 370                         try {
 371                                 Convert.ToByte((int)-256);
 372                                 Assert.Fail ();
 373                         }
 374                         catch (Exception e) {
 375                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E30");
 376                         }
 377
 378                         try {
 379                                 Convert.ToByte(tryInt64);
 380                                 Assert.Fail ();
 381                         }
 382                         catch (Exception e) {
 383                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E31");
 384                         }
 385
 386                         try {
 387                                 Convert.ToByte((object)ci);
 388                                 Assert.Fail ();
 389                         }
 390                         catch (Exception e) {
 391                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#E32");
 392                         }
 393
 394                         try {
 395                                 Convert.ToByte((sbyte)-1);
 396                                 Assert.Fail ();
 397                         }
 398                         catch (Exception e) {
 399                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E33");
 400                         }
 401
 402                         try {
 403                                 Convert.ToByte((float)-0.6f);
 404                                 Assert.Fail ();
 405                         }
 406                         catch (Exception e) {
 407                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E34");
 408                         }
 409
 410                         try {
 411                                 Convert.ToByte("1a1");
 412                                 Assert.Fail ();
 413                         }
 414                         catch (Exception e) {
 415                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#E35");
 416                         }
 417
 418                         try {
 419                                 Convert.ToByte("457");
 420                                 Assert.Fail ();
 421                         }
 422                         catch (Exception e) {
 423                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E36");
 424                         }
 425
 426                         try {
 427                                 Convert.ToByte((ushort)30000);
 428                                 Assert.Fail ();
 429                         }
 430                         catch (Exception e) {
 431                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E37");
 432                         }
 433
 434                         try {
 435                                 Convert.ToByte((uint)300);
 436                                 Assert.Fail ();
 437                         }
 438                         catch (Exception e) {
 439                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E38");
 440                         }
 441
 442                         try {
 443                                 Convert.ToByte((ulong)987654321321);
 444                                 Assert.Fail ();
 445                         }
 446                         catch (Exception e) {
 447                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E39");
 448                         }
 449
 450                         try {
 451                                 Convert.ToByte("10010111", 3);
 452                                 Assert.Fail ();
 453                         }
 454                         catch (Exception e) {
 455                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#E40");
 456                         }
 457
 458                         try {
 459                                 Convert.ToByte("3F3", 16);
 460                                 Assert.Fail ();
 461                         }
 462                         catch (Exception e) {
 463                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#E41");
 464                         }
 465                 }
 466
 467                 public void TestToChar(){
 468                         tryByte = 58;
 469                         Assert.AreEqual (':', Convert.ToChar(tryByte), "#F01");
 470                         Assert.AreEqual ('a', Convert.ToChar(tryChar), "#F02");
 471                         Assert.AreEqual ('A', Convert.ToChar((short)65), "#F03");
 472                         Assert.AreEqual ('x', Convert.ToChar((int)120), "#F04");
 473                         Assert.AreEqual ('"', Convert.ToChar((long)34), "#F05");
 474                         Assert.AreEqual ('-', Convert.ToChar((sbyte)45), "#F06");
 475                         Assert.AreEqual ('@', Convert.ToChar("@"), "#F07");
 476                         Assert.AreEqual ('K', Convert.ToChar((ushort)75), "#F08");
 477                         Assert.AreEqual ('=', Convert.ToChar((uint)61), "#F09");
 478                         // Assert.AreEqual ('E', Convert.ToChar((ulong)200), "#F10");
 479                         Assert.AreEqual ('{', Convert.ToChar((object)trySByte, ci), "#F11");
 480                         Assert.AreEqual ('o', Convert.ToChar(tryStr.Substring(1, 1), ci), "#F12");
 481
 482                         try {
 483                                 Convert.ToChar(boolTrue);
 484                                 Assert.Fail ();
 485                         }
 486                         catch (Exception e) {
 487                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#F20");
 488                         }
 489
 490                         try {
 491                                 Convert.ToChar(tryDT);
 492                                 Assert.Fail ();
 493                         }
 494                         catch (Exception e) {
 495                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#F21");
 496                         }
 497
 498                         try {
 499                                 Convert.ToChar(tryDec);
 500                                 Assert.Fail ();
 501                         }
 502                         catch (Exception e) {
 503                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#F22");
 504                         }
 505
 506                         try {
 507                                 Convert.ToChar(tryDbl);
 508                                 Assert.Fail ();
 509                         }
 510                         catch (Exception e) {
 511                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#F23");
 512                         }
 513
 514                         try {
 515                                 Convert.ToChar((short)-1);
 516                                 Assert.Fail ();
 517                         }
 518                         catch (Exception e) {
 519                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#F24");
 520                         }
 521
 522                         try {
 523                                 Convert.ToChar(Int32.MinValue);
 524                                 Assert.Fail ();
 525                         }
 526                         catch (Exception e) {
 527                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#F25");
 528                         }
 529
 530                         try {
 531                                 Convert.ToChar(Int32.MaxValue);
 532                                 Assert.Fail ();
 533                         }
 534                         catch (Exception e) {
 535                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#F26");
 536                         }
 537
 538                         try {
 539                                 Convert.ToChar(tryInt64);
 540                                 Assert.Fail ();
 541                         }
 542                         catch (Exception e) {
 543                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#F27");
 544                         }
 545
 546                         try {
 547                                 Convert.ToChar((long)-123);
 548                                 Assert.Fail ();
 549                         }
 550                         catch (Exception e) {
 551                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#F28");
 552                         }
 553
 554                         try {
 555                                 Convert.ToChar(ci);
 556                                 Assert.Fail ();
 557                         }
 558                         catch (Exception e) {
 559                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#F29");
 560                         }
 561
 562                         try {
 563                                 Convert.ToChar(-trySByte);
 564                                 Assert.Fail ();
 565                         }
 566                         catch (Exception e) {
 567                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#F30");
 568                         }
 569
 570                         try {
 571                                 Convert.ToChar(tryFloat);
 572                                 Assert.Fail ();
 573                         }
 574                         catch (Exception e) {
 575                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#F31");
 576                         }
 577
 578                         try {
 579                                 Convert.ToChar("foo");
 580                                 Assert.Fail ();
 581                         }
 582                         catch (Exception e) {
 583                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#F32");
 584                         }
 585
 586                         try {
 587                                 Convert.ToChar(null);
 588                                 Assert.Fail ();
 589                         }
 590                         catch (Exception e) {
 591                                 Assert.AreEqual (typeof(ArgumentNullException), e.GetType(), "#F33");
 592                         }
 593
 594                         try {
 595                                 Convert.ToChar(new Exception(), ci);
 596                                 Assert.Fail ();
 597                         }
 598                         catch (Exception e) {
 599                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#F34");
 600                         }
 601
 602                         try {
 603                                 Convert.ToChar(null, ci);
 604                                 Assert.Fail ();
 605                         }
 606                         catch (Exception e) {
 607                                 Assert.AreEqual (typeof(ArgumentNullException), e.GetType(), "#F35");
 608                         }
 609
 610                         try {
 611                                 Convert.ToChar("", ci);
 612                                 Assert.Fail ();
 613                         }
 614                         catch (Exception e) {
 615                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#F36");
 616                         }
 617
 618                         try {
 619                                 Convert.ToChar(tryStr, ci);
 620                                 Assert.Fail ();
 621                         }
 622                         catch (Exception e) {
 623                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#F37");
 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                                 Assert.AreEqual (tryDT, Convert.ToDateTime(tryDT), "#G01");
 639                                 iTest++;
 640                                 Assert.AreEqual (tryDT, Convert.ToDateTime(dateString), "#G02");
 641                                 iTest++;
 642                                 Assert.AreEqual (tryDT, Convert.ToDateTime(dateString, ci), "#G03");
 643                         } catch (Exception e) {
 644                                 Assert.Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
 645                         }
 646
 647                         try {
 648                                 Convert.ToDateTime(boolTrue);
 649                                 Assert.Fail ();
 650                         }
 651                         catch (Exception e) {
 652                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G10");
 653                         }
 654
 655                         try {
 656                                 Convert.ToDateTime(tryByte);
 657                                 Assert.Fail ();
 658                         }
 659                         catch (Exception e) {
 660                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G11");
 661                         }
 662
 663                         try {
 664                                 Convert.ToDateTime(tryChar);
 665                                 Assert.Fail ();
 666                         }
 667                         catch (Exception e) {
 668                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G12");
 669                         }
 670
 671                         try {
 672                                 Convert.ToDateTime(tryDec);
 673                                 Assert.Fail ();
 674                         }
 675                         catch (Exception e) {
 676                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G13");
 677                         }
 678
 679                         try {
 680                                 Convert.ToDateTime(tryDbl);
 681                                 Assert.Fail ();
 682                         }
 683                         catch (Exception e) {
 684                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G14");
 685                         }
 686
 687                         try {
 688                                 Convert.ToDateTime(tryInt16);
 689                                 Assert.Fail ();
 690                         }
 691                         catch (Exception e) {
 692                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G15");
 693                         }
 694
 695                         try {
 696                                 Convert.ToDateTime(tryInt32);
 697                                 Assert.Fail ();
 698                         }
 699                         catch (Exception e) {
 700                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G16");
 701                         }
 702
 703                         try {
 704                                 Convert.ToDateTime(tryInt64);
 705                                 Assert.Fail ();
 706                         }
 707                         catch (Exception e) {
 708                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G17");
 709                         }
 710
 711                         try {
 712                                 Convert.ToDateTime(ci);
 713                                 Assert.Fail ();
 714                         }
 715                         catch (Exception e) {
 716                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G18");
 717                         }
 718
 719                         try {
 720                                 Convert.ToDateTime(trySByte);
 721                                 Assert.Fail ();
 722                         }
 723                         catch (Exception e) {
 724                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G19");
 725                         }
 726
 727                         try {
 728                                 Convert.ToDateTime(tryFloat);
 729                                 Assert.Fail ();
 730                         }
 731                         catch (Exception e) {
 732                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G20");
 733                         }
 734
 735                         try {
 736                                 Convert.ToDateTime("20a2-01-01");
 737                                 Assert.Fail ();
 738                         }
 739                         catch (Exception e) {
 740                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G21");
 741                         }
 742
 743                         try {
 744                                 Convert.ToDateTime(tryUI16);
 745                                 Assert.Fail ();
 746                         }
 747                         catch (Exception e) {
 748                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G23");
 749                         }
 750
 751                         try {
 752                                 Convert.ToDateTime(tryUI32);
 753                                 Assert.Fail ();
 754                         }
 755                         catch (Exception e) {
 756                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G24");
 757                         }
 758
 759                         try {
 760                                 Convert.ToDateTime(tryUI64);
 761                                 Assert.Fail ();
 762                         }
 763                         catch (Exception e) {
 764                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G25");
 765                         }
 766
 767                         try {
 768                                 Convert.ToDateTime(ci, ci);
 769                                 Assert.Fail ();
 770                         }
 771                         catch (Exception e) {
 772                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#G26");
 773                         }
 774
 775                         try {
 776                                 Convert.ToDateTime("20a2-01-01", ci);
 777                                 Assert.Fail ();
 778                         }
 779                         catch (Exception e) {
 780                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G27");
 781                         }
 782
 783                         // this is supported by .net 1.1 (defect 41845)
 784                         try {
 785                                 Convert.ToDateTime("20022-01-01");
 786                                 Assert.Fail ();
 787                         }
 788                         catch (Exception e) {
 789 #if NET_2_0
 790                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G28");
 791 #else
 792                                 Assert.AreEqual (typeof(ArgumentOutOfRangeException), e.GetType(), "#G28");
 793 #endif
 794                         }
 795
 796                         try {
 797                                 Convert.ToDateTime("2002-21-01");
 798                                 Assert.Fail ();
 799                         }
 800                         catch (Exception e) {
 801                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G29");
 802                         }
 803
 804                         try {
 805                                 Convert.ToDateTime("2002-111-01");
 806                                 Assert.Fail ();
 807                         }
 808                         catch (Exception e) {
 809                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G30");
 810                         }
 811
 812                         try {
 813                                 Convert.ToDateTime("2002-01-41");
 814                                 Assert.Fail ();
 815                         }
 816                         catch (Exception e) {
 817                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G31");
 818                         }
 819
 820                         try {
 821                                 Convert.ToDateTime("2002-01-111");
 822                                 Assert.Fail ();
 823                         }
 824                         catch (Exception e) {
 825                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G32");
 826                         }
 827
 828                         try {
 829                                 Assert.AreEqual (tryDT, Convert.ToDateTime("2002-01-01"), "#G33");
 830                         } catch (Exception e) {
 831                                 Assert.Fail ("Unexpected exception at #G33 " + e);
 832                         }
 833
 834                         try {
 835                                 Convert.ToDateTime("2002-01-11 34:11:11");
 836                                 Assert.Fail ();
 837                         }
 838                         catch (Exception e) {
 839                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G34");
 840                         }
 841
 842                         try {
 843                                 Convert.ToDateTime("2002-01-11 11:70:11");
 844                                 Assert.Fail ();
 845                         }
 846                         catch (Exception e) {
 847                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G35");
 848                         }
 849
 850                         try {
 851                                 Convert.ToDateTime("2002-01-11 11:11:70");
 852                                 Assert.Fail ();
 853                         }
 854                         catch (Exception e) {
 855                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#G36");
 856                         }
 857
 858                 }
 859
 860                 public void TestToDecimal() {
 861                         Assert.AreEqual ((decimal)1, Convert.ToDecimal(boolTrue), "#H01");
 862                         Assert.AreEqual ((decimal)0, Convert.ToDecimal(boolFalse), "#H02");
 863                         Assert.AreEqual ((decimal)tryByte, Convert.ToDecimal(tryByte), "#H03");
 864                         Assert.AreEqual (tryDec, Convert.ToDecimal(tryDec), "#H04");
 865                         Assert.AreEqual ((decimal)tryDbl, Convert.ToDecimal(tryDbl), "#H05");
 866                         Assert.AreEqual ((decimal)tryInt16, Convert.ToDecimal(tryInt16), "#H06");
 867                         Assert.AreEqual ((decimal)tryInt32, Convert.ToDecimal(tryInt32), "#H07");
 868                         Assert.AreEqual ((decimal)tryInt64, Convert.ToDecimal(tryInt64), "#H08");
 869                         Assert.AreEqual ((decimal)trySByte, Convert.ToDecimal(trySByte), "#H09");
 870                         Assert.AreEqual ((decimal)tryFloat, Convert.ToDecimal(tryFloat), "#H10");
 871                         string sep = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
 872 //                      Assert.AreEqual ((decimal)23456.432, Convert.ToDecimal("23456" + sep + "432"), "#H11");
 873 //                      Note: changed because the number were the same but with a different base
 874 //                      and this isn't a Convert bug (but a Decimal bug). See #60227 for more details.
 875 //                      http://bugzilla.ximian.com/show_bug.cgi?id=60227
 876                         Assert.IsTrue (Decimal.Equals (23456.432m, Convert.ToDecimal ("23456" + sep + "432")), "#H11");
 877                         Assert.AreEqual ((decimal)tryUI16, Convert.ToDecimal(tryUI16), "#H12");
 878                         Assert.AreEqual ((decimal)tryUI32, Convert.ToDecimal(tryUI32), "#H13");
 879                         Assert.AreEqual ((decimal)tryUI64, Convert.ToDecimal(tryUI64), "#H14");
 880                         Assert.AreEqual ((decimal)63784, Convert.ToDecimal("63784", ci), "#H15");
 881
 882                         try {
 883                                 Convert.ToDecimal(tryChar);
 884                                 Assert.Fail ();
 885                         }
 886                         catch (Exception e) {
 887                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#H20");
 888                         }
 889
 890                         try {
 891                                 Convert.ToDecimal(tryDT);
 892                                 Assert.Fail ();
 893                         }
 894                         catch (Exception e) {
 895                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#H21");
 896                         }
 897
 898                         try {
 899                                 Convert.ToDecimal(double.MaxValue);
 900                                 Assert.Fail ();
 901                         }
 902                         catch (Exception e) {
 903                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#H22");
 904                         }
 905
 906                         try {
 907                                 Convert.ToDecimal(double.MinValue);
 908                                 Assert.Fail ();
 909                         }
 910                         catch (Exception e) {
 911                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#H23");
 912                         }
 913
 914                         try {
 915                                 Convert.ToDecimal(ci);
 916                                 Assert.Fail ();
 917                         }
 918                         catch (Exception e) {
 919                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#H24");
 920                         }
 921
 922                         try {
 923                                 Convert.ToDecimal(tryStr);
 924                                 Assert.Fail ();
 925                         }
 926                         catch (Exception e) {
 927                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#H25");
 928                         }
 929
 930                         try {
 931                                 string maxDec = decimal.MaxValue.ToString();
 932                                 maxDec = maxDec + "1";
 933                                 Convert.ToDecimal(maxDec);
 934                                 Assert.Fail ();
 935                         }
 936                         catch (Exception e) {
 937                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#H26");
 938                         }
 939
 940                         try {
 941                                 Convert.ToDecimal(ci, ci);
 942                                 Assert.Fail ();
 943                         }
 944                         catch (Exception e) {
 945                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#H27");
 946                         }
 947
 948                         try {
 949                                 Convert.ToDecimal(tryStr, ci);
 950                                 Assert.Fail ();
 951                         }
 952                         catch (Exception e) {
 953                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#H28");
 954                         }
 955
 956                         try {
 957                                 string maxDec = decimal.MaxValue.ToString();
 958                                 maxDec = maxDec + "1";
 959                                 Convert.ToDecimal(maxDec, ci);
 960                                 Assert.Fail ();
 961                         }
 962                         catch (Exception e) {
 963                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#H29");
 964                         }
 965                 }
 966
 967                 public void TestToDouble() {
 968                         int iTest = 1;
 969                         try {
 970                                 Assert.AreEqual ((double)1, Convert.ToDouble(boolTrue), "#I01");
 971                                 iTest++;
 972                                 Assert.AreEqual ((double)0, Convert.ToDouble(boolFalse), "#I02");
 973                                 iTest++;
 974                                 Assert.AreEqual ((double)tryByte, Convert.ToDouble(tryByte), "#I03");
 975                                 iTest++;
 976                                 Assert.AreEqual (tryDbl, Convert.ToDouble(tryDbl), "#I04");
 977                                 iTest++;
 978                                 Assert.AreEqual ((double)tryDec, Convert.ToDouble(tryDec), "#I05");
 979                                 iTest++;
 980                                 Assert.AreEqual ((double)tryInt16, Convert.ToDouble(tryInt16), "#I06");
 981                                 iTest++;
 982                                 Assert.AreEqual ((double)tryInt32, Convert.ToDouble(tryInt32), "#I07");
 983                                 iTest++;
 984                                 Assert.AreEqual ((double)tryInt64, Convert.ToDouble(tryInt64), "#I08");
 985                                 iTest++;
 986                                 Assert.AreEqual ((double)trySByte, Convert.ToDouble(trySByte), "#I09");
 987                                 iTest++;
 988                                 Assert.AreEqual ((double)tryFloat, Convert.ToDouble(tryFloat), "#I10");
 989                                 iTest++;
 990                                 string sep = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
 991                                 Assert.AreEqual ((double)23456.432, Convert.ToDouble("23456" + sep + "432"), "#I11");
 992                                 iTest++;
 993                                 Assert.AreEqual ((double)tryUI16, Convert.ToDouble(tryUI16), "#I12");
 994                                 iTest++;
 995                                 Assert.AreEqual ((double)tryUI32, Convert.ToDouble(tryUI32), "#I13");
 996                                 iTest++;
 997                                 Assert.AreEqual ((double)tryUI64, Convert.ToDouble(tryUI64), "#I14");
 998                                 iTest++;
 999                                 Assert.AreEqual ((double)63784, Convert.ToDouble("63784", ci), "#H15");
1000                         } catch (Exception e) {
1001                                 Assert.Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
1002                         }
1003
1004                         try {
1005                                 Convert.ToDouble(tryChar);
1006                                 Assert.Fail ();
1007                         }
1008                         catch (Exception e) {
1009                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#I20");
1010                         }
1011
1012                         try {
1013                                 Convert.ToDouble(tryDT);
1014                                 Assert.Fail ();
1015                         }
1016                         catch (Exception e) {
1017                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#I21");
1018                         }
1019
1020                         try {
1021                                 Convert.ToDouble(ci);
1022                                 Assert.Fail ();
1023                         }
1024                         catch (Exception e) {
1025                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#I22");
1026                         }
1027
1028                         try {
1029                                 Convert.ToDouble(tryStr);
1030                                 Assert.Fail ();
1031                         }
1032                         catch (Exception e) {
1033                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#I23");
1034                         }
1035
1036                         try {
1037                                 string maxDec = double.MaxValue.ToString();
1038                                 maxDec = maxDec + "1";
1039                                 Convert.ToDouble(maxDec);
1040                                 Assert.Fail ();
1041                         }
1042                         catch (Exception e) {
1043                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#I24");
1044                         }
1045
1046                         try {
1047                                 Convert.ToDouble(ci, ci);
1048                                 Assert.Fail ();
1049                         }
1050                         catch (Exception e) {
1051                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#I25");
1052                         }
1053
1054                         try {
1055                                 Convert.ToDouble(tryStr, ci);
1056                                 Assert.Fail ();
1057                         }
1058                         catch (Exception e) {
1059                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#I26");
1060                         }
1061
1062                         try {
1063                                 string maxDec = double.MaxValue.ToString();
1064                                 maxDec = maxDec + "1";
1065                                 Convert.ToDouble(maxDec, ci);
1066                                 Assert.Fail ();
1067                         }
1068                         catch (Exception e) {
1069                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#I27");
1070                         }
1071
1072                         try {
1073                                 Convert.ToDouble(tryObj, ci);
1074                                 Assert.Fail ();
1075                         }
1076                         catch (Exception e) {
1077                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#I28");
1078                         }
1079                 }
1080
1081                 public void TestToInt16() {
1082                         Assert.AreEqual ((short)0, Convert.ToInt16(boolFalse), "#J01");
1083                         Assert.AreEqual ((short)1, Convert.ToInt16(boolTrue), "#J02");
1084                         Assert.AreEqual ((short)97, Convert.ToInt16(tryChar), "#J03");
1085                         Assert.AreEqual ((short)1234, Convert.ToInt16(tryDec), "#J04");
1086                         Assert.AreEqual ((short)0, Convert.ToInt16(tryDbl), "#J05");
1087                         Assert.AreEqual ((short)1234, Convert.ToInt16(tryInt16), "#J06");
1088                         Assert.AreEqual ((short)12345, Convert.ToInt16(tryInt32), "#J07");
1089                         Assert.AreEqual ((short)30000, Convert.ToInt16((long)30000), "#J08");
1090                         Assert.AreEqual ((short)123, Convert.ToInt16(trySByte), "#J09");
1091                         Assert.AreEqual ((short)1234, Convert.ToInt16(tryFloat), "#J10");
1092                         Assert.AreEqual ((short)578, Convert.ToInt16("578"), "#J11");
1093                         Assert.AreEqual ((short)15500, Convert.ToInt16((ushort)15500), "#J12");
1094                         Assert.AreEqual ((short)5489, Convert.ToInt16((uint)5489), "#J13");
1095                         Assert.AreEqual ((short)9876, Convert.ToInt16((ulong)9876), "#J14");
1096                         Assert.AreEqual ((short)14, Convert.ToInt16("14", ci), "#J15");
1097                         Assert.AreEqual ((short)11, Convert.ToInt16("01011", 2), "#J16");
1098                         Assert.AreEqual ((short)1540, Convert.ToInt16("3004", 8), "#J17");
1099                         Assert.AreEqual ((short)321, Convert.ToInt16("321", 10), "#J18");
1100                         Assert.AreEqual ((short)2748, Convert.ToInt16("ABC", 16), "#J19");
1101
1102                         try {
1103                                 Convert.ToInt16(char.MaxValue);
1104                                 Assert.Fail ();
1105                         }
1106                         catch (Exception e) {
1107                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J25");
1108                         }
1109
1110                         try {
1111                                 Convert.ToInt16(tryDT);
1112                                 Assert.Fail ();
1113                         }
1114                         catch (Exception e) {
1115                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#J26");
1116                         }
1117
1118                         try {
1119                                 Convert.ToInt16((decimal)(short.MaxValue + 1));
1120                                 Assert.Fail ();
1121                         }
1122                         catch (Exception e) {
1123                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J27");
1124                         }
1125
1126                         try {
1127                                 Convert.ToInt16((decimal)(short.MinValue - 1));
1128                                 Assert.Fail ();
1129                         }
1130                         catch (Exception e) {
1131                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J28");
1132                         }
1133
1134                         try {
1135                                 Convert.ToInt16((double)(short.MaxValue + 1));
1136                                 Assert.Fail ();
1137                         }
1138                         catch (Exception e) {
1139                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J29");
1140                         }
1141
1142                         try {
1143                                 Convert.ToInt16((double)(short.MinValue - 1));
1144                                 Assert.Fail ();
1145                         }
1146                         catch (Exception e) {
1147                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J30");
1148                         }
1149
1150                         try {
1151                                 Convert.ToInt16(50000);
1152                                 Assert.Fail ();
1153                         }
1154                         catch (Exception e) {
1155                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J31");
1156                         }
1157
1158                         try {
1159                                 Convert.ToInt16(-50000);
1160                                 Assert.Fail ();
1161                         }
1162                         catch (Exception e) {
1163                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J32");
1164                         }
1165
1166                         try {
1167                                 Convert.ToInt16(tryInt64);
1168                                 Assert.Fail ();
1169                         }
1170                         catch (Exception e) {
1171                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J33");
1172                         }
1173
1174                         try {
1175                                 Convert.ToInt16(-tryInt64);
1176                                 Assert.Fail ();
1177                         }
1178                         catch (Exception e) {
1179                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J34");
1180                         }
1181
1182                         try {
1183                                 Convert.ToInt16(tryObj);
1184                                 Assert.Fail ();
1185                         }
1186                         catch (Exception e) {
1187                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#J35");
1188                         }
1189
1190                         try {
1191                                 Convert.ToInt16((float)32767.5);
1192                                 Assert.Fail ();
1193                         }
1194                         catch (Exception e) {
1195                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J36");
1196                         }
1197
1198                         try {
1199                                 Convert.ToInt16((float)-33000.54);
1200                                 Assert.Fail ();
1201                         }
1202                         catch (Exception e) {
1203                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J37");
1204                         }
1205
1206                         try {
1207                                 Convert.ToInt16(tryStr);
1208                                 Assert.Fail ();
1209                         }
1210                         catch (Exception e) {
1211                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#J38");
1212                         }
1213
1214                         try {
1215                                 Convert.ToInt16("-33000");
1216                                 Assert.Fail ();
1217                         }
1218                         catch (Exception e) {
1219                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J39");
1220                         }
1221
1222                         try {
1223                                 Convert.ToInt16(ushort.MaxValue);
1224                                 Assert.Fail ();
1225                         }
1226                         catch (Exception e) {
1227                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J40");
1228                         }
1229
1230                         try {
1231                                 Convert.ToInt16(uint.MaxValue);
1232                                 Assert.Fail ();
1233                         }
1234                         catch (Exception e) {
1235                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J41");
1236                         }
1237
1238                         try {
1239                                 Convert.ToInt16(ulong.MaxValue);
1240                                 Assert.Fail ();
1241                         }
1242                         catch (Exception e) {
1243                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J42");
1244                         }
1245
1246                         try {
1247                                 Convert.ToInt16(tryObj, ci);
1248                                 Assert.Fail ();
1249                         }
1250                         catch (Exception e) {
1251                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#J43");
1252                         }
1253
1254                         try {
1255                                 Convert.ToInt16(tryStr, ci);
1256                                 Assert.Fail ();
1257                         }
1258                         catch (Exception e) {
1259                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#J44");
1260                         }
1261
1262                         try {
1263                                 Convert.ToInt16("-33000", ci);
1264                                 Assert.Fail ();
1265                         }
1266                         catch (Exception e) {
1267                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J45");
1268                         }
1269
1270                         try {
1271                                 Convert.ToInt16("321", 11);
1272                                 Assert.Fail ();
1273                         }
1274                         catch (Exception e) {
1275                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#J46");
1276                         }
1277
1278                         try {
1279                                 Convert.ToInt16("D8BF1", 16);
1280                                 Assert.Fail ();
1281                         }
1282                         catch (Exception e) {
1283                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#J47");
1284                         }
1285                 }
1286
1287                 public void TestToInt32() {
1288                         long tryMax = long.MaxValue;
1289                         long tryMin = long.MinValue;
1290                         Assert.AreEqual ((int)0, Convert.ToInt32(boolFalse), "#K01");
1291                         Assert.AreEqual ((int)1, Convert.ToInt32(boolTrue), "#K02");
1292                         Assert.AreEqual ((int)0, Convert.ToInt32(tryByte), "#K03");
1293                         Assert.AreEqual ((int)97, Convert.ToInt32(tryChar), "#K04");
1294                         Assert.AreEqual ((int)1234, Convert.ToInt32(tryDec), "#K05");
1295                         Assert.AreEqual ((int)0, Convert.ToInt32(tryDbl), "#K06");
1296                         Assert.AreEqual ((int)1234, Convert.ToInt32(tryInt16), "#K07");
1297                         Assert.AreEqual ((int)12345, Convert.ToInt32(tryInt32), "#K08");
1298                         Assert.AreEqual ((int)60000, Convert.ToInt32((long)60000), "#K09");
1299                         Assert.AreEqual ((int)123, Convert.ToInt32(trySByte), "#K10");
1300                         Assert.AreEqual ((int)1234, Convert.ToInt32(tryFloat), "#K11");
1301                         Assert.AreEqual ((int)9876, Convert.ToInt32((string)"9876"), "#K12");
1302                         Assert.AreEqual ((int)34567, Convert.ToInt32(tryUI16), "#K13");
1303                         Assert.AreEqual ((int)567891234, Convert.ToInt32(tryUI32), "#K14");
1304                         Assert.AreEqual ((int)0, Convert.ToInt32(tryUI64), "#K15");
1305                         Assert.AreEqual ((int)123, Convert.ToInt32("123", ci), "#K16");
1306                         Assert.AreEqual ((int)128, Convert.ToInt32("10000000", 2), "#K17");
1307                         Assert.AreEqual ((int)302, Convert.ToInt32("456", 8), "#K18");
1308                         Assert.AreEqual ((int)456, Convert.ToInt32("456", 10), "#K19");
1309                         Assert.AreEqual ((int)1110, Convert.ToInt32("456", 16), "#K20");
1310
1311                         try {
1312                                 Convert.ToInt32(tryDT);
1313                                 Assert.Fail ();
1314                         }
1315                         catch (Exception e) {
1316                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#K25");
1317                         }
1318
1319                         try {
1320                                 Convert.ToInt32((decimal)tryMax);
1321                                 Assert.Fail ();
1322                         }
1323                         catch (Exception e) {
1324                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K26");
1325                         }
1326
1327                         try {
1328                                 Convert.ToInt32((decimal)tryMin);
1329                                 Assert.Fail ();
1330                         }
1331                         catch (Exception e) {
1332                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K27");
1333                         }
1334
1335                         try {
1336                                 Convert.ToInt32((double)tryMax);
1337                                 Assert.Fail ();
1338                         }
1339                         catch (Exception e) {
1340                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K28");
1341                         }
1342
1343                         try {
1344                                 Convert.ToInt32((double)tryMin);
1345                                 Assert.Fail ();
1346                         }
1347                         catch (Exception e) {
1348                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K29");
1349                         }
1350
1351                         try {
1352                                 Convert.ToInt32(tryInt64);
1353                                 Assert.Fail ();
1354                         }
1355                         catch (Exception e) {
1356                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K30");
1357                         }
1358
1359                         try {
1360                                 Convert.ToInt32(-tryInt64);
1361                                 Assert.Fail ();
1362                         }
1363                         catch (Exception e) {
1364                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K31");
1365                         }
1366
1367                         try {
1368                                 Convert.ToInt32(tryObj);
1369                                 Assert.Fail ();
1370                         }
1371                         catch (Exception e) {
1372                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#K32");
1373                         }
1374
1375                         try {
1376                                 Convert.ToInt32((float)tryMax);
1377                                 Assert.Fail ();
1378                         }
1379                         catch (Exception e) {
1380                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K33");
1381                         }
1382
1383                         try {
1384                                 Convert.ToInt32((float)tryMin);
1385                                 Assert.Fail ();
1386                         }
1387                         catch (Exception e) {
1388                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K34");
1389                         }
1390
1391                         try {
1392                                 Convert.ToInt32(tryStr, ci);
1393                                 Assert.Fail ();
1394                         }
1395                         catch (Exception e) {
1396                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#K35");
1397                         }
1398
1399                         try {
1400                                 Convert.ToInt32("-46565465123");
1401                                 Assert.Fail ();
1402                         }
1403                         catch (Exception e) {
1404                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K36");
1405                         }
1406
1407                         try {
1408                                 Convert.ToInt32("46565465123");
1409                                 Assert.Fail ();
1410                         }
1411                         catch (Exception e) {
1412                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K37");
1413                         }
1414
1415                         try {
1416                                 Convert.ToInt32((uint)tryMax);
1417                                 Assert.Fail ();
1418                         }
1419                         catch (Exception e) {
1420                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K38");
1421                         }
1422
1423                         try {
1424                                 Convert.ToInt32((ulong)tryMax);
1425                                 Assert.Fail ();
1426                         }
1427                         catch (Exception e) {
1428                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K39");
1429                         }
1430
1431                         try {
1432                                 Convert.ToInt32(tryObj, ci);
1433                                 Assert.Fail ();
1434                         }
1435                         catch (Exception e) {
1436                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#K40");
1437                         }
1438
1439                         try {
1440                                 Convert.ToInt32(tryStr, ci);
1441                                 Assert.Fail ();
1442                         }
1443                         catch (Exception e) {
1444                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#K41");
1445                         }
1446
1447                         try {
1448                                 Convert.ToInt32("-46565465123", ci);
1449                                 Assert.Fail ();
1450                         }
1451                         catch (Exception e) {
1452                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#K42");
1453                         }
1454
1455                         try {
1456                                 Convert.ToInt32("654", 9);
1457                                 Assert.Fail ();
1458                         }
1459                         catch (Exception e) {
1460                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#K43");
1461                         }
1462                 }
1463
1464                 public void TestToInt64() {
1465                         decimal longMax = long.MaxValue;
1466                         longMax += 1000000;
1467                         decimal longMin = long.MinValue;
1468                         longMin -= 1000000;
1469
1470                         Assert.AreEqual ((long)0, Convert.ToInt64(boolFalse), "#L01");
1471                         Assert.AreEqual ((long)1, Convert.ToInt64(boolTrue), "#L02");
1472                         Assert.AreEqual ((long)97, Convert.ToInt64(tryChar), "#L03");
1473                         Assert.AreEqual ((long)1234, Convert.ToInt64(tryDec), "#L04");
1474                         Assert.AreEqual ((long)0, Convert.ToInt64(tryDbl), "#L05");
1475                         Assert.AreEqual ((long)1234, Convert.ToInt64(tryInt16), "#L06");
1476                         Assert.AreEqual ((long)12345, Convert.ToInt64(tryInt32), "#L07");
1477                         Assert.AreEqual ((long)123456789012, Convert.ToInt64(tryInt64), "#L08");
1478                         Assert.AreEqual ((long)123, Convert.ToInt64(trySByte), "#L09");
1479                         Assert.AreEqual ((long)1234, Convert.ToInt64(tryFloat), "#L10");
1480                         Assert.AreEqual ((long)564897, Convert.ToInt64("564897"), "#L11");
1481                         Assert.AreEqual ((long)34567, Convert.ToInt64(tryUI16), "#L12");
1482                         Assert.AreEqual ((long)567891234, Convert.ToInt64(tryUI32), "#L13");
1483                         Assert.AreEqual ((long)0, Convert.ToInt64(tryUI64), "#L14");
1484                         Assert.AreEqual ((long)-2548751, Convert.ToInt64("-2548751", ci), "#L15");
1485                         Assert.AreEqual ((long)24987562, Convert.ToInt64("1011111010100011110101010", 2), "#L16");
1486                         Assert.AreEqual ((long)-24578965, Convert.ToInt64("1777777777777642172153", 8), "#L17");
1487                         Assert.AreEqual ((long)248759757, Convert.ToInt64("248759757", 10), "#L18");
1488                         Assert.AreEqual ((long)256, Convert.ToInt64("100", 16), "#L19");
1489
1490                         try {
1491                                 Convert.ToInt64(tryDT);
1492                                 Assert.Fail ();
1493                         }
1494                         catch (Exception e) {
1495                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#L20");
1496                         }
1497
1498                         try {
1499                                 Convert.ToInt64((decimal)longMax + 1);
1500                                 Assert.Fail ();
1501                         }
1502                         catch (Exception e) {
1503                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L21");
1504                         }
1505
1506                         try {
1507                                 Convert.ToInt64((decimal)longMin);
1508                                 Assert.Fail ();
1509                         }
1510                         catch (Exception e) {
1511                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L24");
1512                         }
1513
1514                         try {
1515                                 Convert.ToInt64((double)longMax);
1516                                 Assert.Fail ();
1517                         }
1518                         catch (Exception e) {
1519                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L25:"+longMax);
1520                         }
1521
1522                         try {
1523                                 Convert.ToInt64((double)longMin);
1524                                 Assert.Fail ();
1525                         }
1526                         catch (Exception e) {
1527                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L26");
1528                         }
1529
1530                         try {
1531                                 Convert.ToInt64(new Exception());
1532                                 Assert.Fail ();
1533                         }
1534                         catch (Exception e) {
1535                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#L27");
1536                         }
1537
1538                         try {
1539                                 Convert.ToInt64(((float)longMax)*100);
1540                                 Assert.Fail ();
1541                         }
1542                         catch (Exception e) {
1543                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L28:"+longMax);
1544                         }
1545
1546                         try {
1547                                 Convert.ToInt64(((float)longMin)*100);
1548                                 Assert.Fail ();
1549                         }
1550                         catch (Exception e) {
1551                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L29");
1552                         }
1553
1554                         try {
1555                                 Convert.ToInt64("-567b3");
1556                                 Assert.Fail ();
1557                         }
1558                         catch (Exception e) {
1559                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#L30");
1560                         }
1561
1562                         try {
1563                                 Convert.ToInt64(longMax.ToString());
1564                                 Assert.Fail ();
1565                         }
1566                         catch (Exception e) {
1567                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L31:");
1568                         }
1569
1570                         try {
1571                                 Convert.ToInt64(ulong.MaxValue);
1572                                 Assert.Fail ();
1573                         }
1574                         catch (Exception e) {
1575                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L32");
1576                         }
1577
1578                         try {
1579                                 Convert.ToInt64(tryStr, ci);
1580                                 Assert.Fail ();
1581                         }
1582                         catch (Exception e) {
1583                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#L32b");
1584                         }
1585
1586                         try {
1587                                 Convert.ToInt64(longMin.ToString(), ci);
1588                                 Assert.Fail ();
1589                         }
1590                         catch (Exception e) {
1591                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#L33");
1592                         }
1593
1594                         try {
1595                                 Convert.ToInt64("321", 11);
1596                                 Assert.Fail ();
1597                         }
1598                         catch (Exception e) {
1599                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#L34");
1600                         }
1601                 }
1602
1603                 public void TestToSByte() {
1604                         int iTest = 1;
1605                         try {
1606                                 Assert.AreEqual ((sbyte)0, Convert.ToSByte(boolFalse), "#M01");
1607                                 iTest++;
1608                                 Assert.AreEqual ((sbyte)1, Convert.ToSByte(boolTrue), "#M02");
1609                                 iTest++;
1610                                 Assert.AreEqual ((sbyte)97, Convert.ToSByte(tryChar), "#M03");
1611                                 iTest++;
1612                                 Assert.AreEqual ((sbyte)15, Convert.ToSByte((decimal)15), "#M04");
1613                                 iTest++;
1614                                 Assert.AreEqual ((sbyte)0, Convert.ToSByte(tryDbl), "#M05");
1615                                 iTest++;
1616                                 Assert.AreEqual ((sbyte)127, Convert.ToSByte((short)127), "#M06");
1617                                 iTest++;
1618                                 Assert.AreEqual ((sbyte)-128, Convert.ToSByte((int)-128), "#M07");
1619                                 iTest++;
1620                                 Assert.AreEqual ((sbyte)30, Convert.ToSByte((long)30), "#M08");
1621                                 iTest++;
1622                                 Assert.AreEqual ((sbyte)123, Convert.ToSByte(trySByte), "#M09");
1623                                 iTest++;
1624                                 Assert.AreEqual ((sbyte)12, Convert.ToSByte((float)12.46987f), "#M10");
1625                                 iTest++;
1626                                 Assert.AreEqual ((sbyte)1, Convert.ToSByte("1"), "#M11");
1627                                 iTest++;
1628                                 Assert.AreEqual ((sbyte)99, Convert.ToSByte((ushort)99), "#M12");
1629                                 iTest++;
1630                                 Assert.AreEqual ((sbyte)54, Convert.ToSByte((uint)54), "#M13");
1631                                 iTest++;
1632                                 Assert.AreEqual ((sbyte)127, Convert.ToSByte((ulong)127), "#M14");
1633                                 iTest++;
1634                                 Assert.AreEqual ((sbyte)14, Convert.ToSByte("14", ci), "#M15");
1635                                 iTest++;
1636                                 Assert.AreEqual ((sbyte)11, Convert.ToSByte("01011", 2), "#M16");
1637                                 iTest++;
1638                                 Assert.AreEqual ((sbyte)5, Convert.ToSByte("5", 8), "#M17");
1639                                 iTest++;
1640                                 Assert.AreEqual ((sbyte)100, Convert.ToSByte("100", 10), "#M18");
1641                                 iTest++;
1642                                 Assert.AreEqual ((sbyte)-1, Convert.ToSByte("FF", 16), "#M19");
1643                         } catch (Exception e) {
1644                                 Assert.Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
1645                         }
1646
1647                         try {
1648                                 Convert.ToSByte((byte)200);
1649                                 Assert.Fail ();
1650                         }
1651                         catch (Exception e) {
1652                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M25");
1653                         }
1654
1655                         try {
1656                                 Convert.ToSByte((char)130);
1657                                 Assert.Fail ();
1658                         }
1659                         catch (Exception e) {
1660                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M26");
1661                         }
1662
1663                         try {
1664                                 Convert.ToSByte(tryDT);
1665                                 Assert.Fail ();
1666                         }
1667                         catch (Exception e) {
1668                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#M27");
1669                         }
1670
1671                         try {
1672                                 Convert.ToSByte((decimal)127.5m);
1673                                 Assert.Fail ();
1674                         }
1675                         catch (Exception e) {
1676                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M28");
1677                         }
1678
1679                         try {
1680                                 Convert.ToSByte((decimal)-200m);
1681                                 Assert.Fail ();
1682                         }
1683                         catch (Exception e) {
1684                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M29");
1685                         }
1686
1687                         try {
1688                                 Convert.ToSByte((double)150);
1689                                 Assert.Fail ();
1690                         }
1691                         catch (Exception e) {
1692                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M30");
1693                         }
1694
1695                         try {
1696                                 Convert.ToSByte((double)-128.6);
1697                                 Assert.Fail ();
1698                         }
1699                         catch (Exception e) {
1700                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M31");
1701                         }
1702
1703                         try {
1704                                 Convert.ToSByte((short)150);
1705                                 Assert.Fail ();
1706                         }
1707                         catch (Exception e) {
1708                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M32");
1709                         }
1710
1711                         try {
1712                                 Convert.ToSByte((short)-300);
1713                                 Assert.Fail ();
1714                         }
1715                         catch (Exception e) {
1716                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M33");
1717                         }
1718
1719                         try {
1720                                 Convert.ToSByte((int)1500);
1721                                 Assert.Fail ();
1722                         }
1723                         catch (Exception e) {
1724                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M34");
1725                         }
1726
1727                         try {
1728                                 Convert.ToSByte((int)-1286);
1729                                 Assert.Fail ();
1730                         }
1731                         catch (Exception e) {
1732                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M35");
1733                         }
1734
1735                         try {
1736                                 Convert.ToSByte((long)128);
1737                                 Assert.Fail ();
1738                         }
1739                         catch (Exception e) {
1740                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M36");
1741                         }
1742
1743                         try {
1744                                 Convert.ToSByte((long)-129);
1745                                 Assert.Fail ();
1746                         }
1747                         catch (Exception e) {
1748                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M37");
1749                         }
1750
1751                         try {
1752                                 Convert.ToSByte(new NumberFormatInfo());
1753                                 Assert.Fail ();
1754                         }
1755                         catch (Exception e) {
1756                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#M38");
1757                         }
1758
1759                         try {
1760                                 Convert.ToSByte((float)333);
1761                                 Assert.Fail ();
1762                         }
1763                         catch (Exception e) {
1764                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M39");
1765                         }
1766
1767                         try {
1768                                 Convert.ToSByte((float)-666);
1769                                 Assert.Fail ();
1770                         }
1771                         catch (Exception e) {
1772                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M40");
1773                         }
1774
1775                         try {
1776                                 Convert.ToSByte("B3");
1777                                 Assert.Fail ();
1778                         }
1779                         catch (Exception e) {
1780                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#M41");
1781                         }
1782
1783                         try {
1784                                 Convert.ToSByte("251");
1785                                 Assert.Fail ();
1786                         }
1787                         catch (Exception e) {
1788                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M42");
1789                         }
1790
1791                         try {
1792                                 Convert.ToSByte(ushort.MaxValue);
1793                                 Assert.Fail ();
1794                         }
1795                         catch (Exception e) {
1796                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M43");
1797                         }
1798
1799                         try {
1800                                 Convert.ToSByte((uint)600);
1801                                 Assert.Fail ();
1802                         }
1803                         catch (Exception e) {
1804                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M44");
1805                         }
1806
1807                         try {
1808                                 Convert.ToSByte(ulong.MaxValue);
1809                                 Assert.Fail ();
1810                         }
1811                         catch (Exception e) {
1812                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M45");
1813                         }
1814
1815                         try {
1816                                 Convert.ToSByte(ci, ci);
1817                                 Assert.Fail ();
1818                         }
1819                         catch (Exception e) {
1820                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#M46");
1821                         }
1822
1823                         try {
1824                                 Convert.ToSByte(tryStr, ci);
1825                                 Assert.Fail ();
1826                         }
1827                         catch (Exception e) {
1828                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#M47");
1829                         }
1830
1831                         try {
1832                                 Convert.ToSByte("325", ci);
1833                                 Assert.Fail ();
1834                         }
1835                         catch (Exception e) {
1836                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M48");
1837                         }
1838
1839                         try {
1840                                 Convert.ToSByte("5D", 15);
1841                                 Assert.Fail ();
1842                         }
1843                         catch (Exception e) {
1844                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#M49");
1845                         }
1846
1847                         try {
1848                                 Convert.ToSByte("111111111", 2);
1849                                 Assert.Fail ();
1850                         }
1851                         catch (Exception e) {
1852                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#M50");
1853                         }
1854                 }
1855
1856                 public void TestToSingle() {
1857                         int iTest = 1;
1858                         try {
1859                                 Assert.AreEqual ((float)0, Convert.ToSingle(boolFalse), "#N01");
1860                                 iTest++;
1861                                 Assert.AreEqual ((float)1, Convert.ToSingle(boolTrue), "#N02");
1862                                 iTest++;
1863                                 Assert.AreEqual ((float)0, Convert.ToSingle(tryByte), "#N03");
1864                                 iTest++;
1865                                 Assert.AreEqual ((float)1234, 234, Convert.ToSingle(tryDec), "#N04");
1866                                 iTest++;
1867                                 Assert.AreEqual ((float)0, Convert.ToSingle(tryDbl), "#N05");
1868                                 iTest++;
1869                                 Assert.AreEqual ((float)1234, Convert.ToSingle(tryInt16), "#N06");
1870                                 iTest++;
1871                                 Assert.AreEqual ((float)12345, Convert.ToSingle(tryInt32), "#N07");
1872                                 iTest++;
1873                                 Assert.AreEqual ((float)123456789012, Convert.ToSingle(tryInt64), "#N08");
1874                                 iTest++;
1875                                 Assert.AreEqual ((float)123, Convert.ToSingle(trySByte), "#N09");
1876                                 iTest++;
1877                                 Assert.AreEqual ((float)1234, 2345, Convert.ToSingle(tryFloat), "#N10");
1878                                 iTest++;
1879                                 Assert.AreEqual ((float)987, Convert.ToSingle("987"), "#N11");
1880                                 iTest++;
1881                                 Assert.AreEqual ((float)34567, Convert.ToSingle(tryUI16), "#N12");
1882                                 iTest++;
1883                                 Assert.AreEqual ((float)567891234, Convert.ToSingle(tryUI32), "#N13");
1884                                 iTest++;
1885                                 Assert.AreEqual ((float)0, Convert.ToSingle(tryUI64), "#N14");
1886                                 iTest++;
1887                                 Assert.AreEqual ((float)654.234, Convert.ToSingle("654.234", ci), "#N15");
1888                         } catch (Exception e) {
1889                                 Assert.Fail ("Unexpected exception at iTest = " + iTest + ": e = " + e);
1890                         }
1891
1892                         try {
1893                                 Convert.ToSingle(tryChar);
1894                                 Assert.Fail ();
1895                         }
1896                         catch (Exception e) {
1897                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#N25");
1898                         }
1899
1900                         try {
1901                                 Convert.ToSingle(tryDT);
1902                                 Assert.Fail ();
1903                         }
1904                         catch (Exception e) {
1905                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#N26");
1906                         }
1907
1908                         try {
1909                                 Convert.ToSingle(tryObj);
1910                                 Assert.Fail ();
1911                         }
1912                         catch (Exception e) {
1913                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#N27");
1914                         }
1915
1916                         try {
1917                                 Convert.ToSingle("A345H");
1918                                 Assert.Fail ();
1919                         }
1920                         catch (Exception e) {
1921                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#N28");
1922                         }
1923
1924                         try {
1925                                 Convert.ToSingle(double.MaxValue.ToString());
1926                                 Assert.Fail ();
1927                         }
1928                         catch (Exception e) {
1929                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#N29");
1930                         }
1931
1932                         try {
1933                                 Convert.ToSingle(tryObj, ci);
1934                                 Assert.Fail ();
1935                         }
1936                         catch (Exception e) {
1937                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#N30");
1938                         }
1939
1940                         try {
1941                                 Convert.ToSingle("J345K", ci);
1942                                 Assert.Fail ();
1943                         }
1944                         catch (Exception e) {
1945                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#N31");
1946                         }
1947
1948                         try {
1949                                 Convert.ToSingle("11000000000000000000000000000000000000000000000", ci);
1950                                 Assert.Fail ();
1951                         }
1952                         catch (Exception e) {
1953                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#N32");
1954                         }
1955                 }
1956
1957                 public void TestToString() {
1958
1959                         tryByte = 123;
1960                         Assert.AreEqual ("False", Convert.ToString(boolFalse), "#O01");
1961                         Assert.AreEqual ("True", Convert.ToString(boolTrue), "#O02");
1962                         Assert.AreEqual ("123", Convert.ToString(tryByte), "#O03");
1963                         Assert.AreEqual ("a", Convert.ToString(tryChar), "#O04");
1964                         Assert.AreEqual (tryDT.ToString(), Convert.ToString(tryDT), "#O05");
1965                         Assert.AreEqual (tryDec.ToString(), Convert.ToString(tryDec), "#O06");
1966                         Assert.AreEqual (tryDbl.ToString(), Convert.ToString(tryDbl), "#O07");
1967                         Assert.AreEqual ("1234", Convert.ToString(tryInt16), "#O08");
1968                         Assert.AreEqual ("12345", Convert.ToString(tryInt32), "#O09");
1969                         Assert.AreEqual ("123456789012", Convert.ToString(tryInt64), "#O10");
1970                         Assert.AreEqual ("123", Convert.ToString(trySByte), "#O11");
1971                         Assert.AreEqual (tryFloat.ToString(), Convert.ToString(tryFloat), "#O12");
1972                         Assert.AreEqual ("foobar", Convert.ToString(tryStr), "#O13");
1973                         Assert.AreEqual ("34567", Convert.ToString(tryUI16), "#O14");
1974                         Assert.AreEqual ("567891234", Convert.ToString(tryUI32), "#O15");
1975                         Assert.AreEqual ("True", Convert.ToString(boolTrue, ci), "#O16");
1976                         Assert.AreEqual ("False", Convert.ToString(boolFalse, ci), "#O17");
1977                         Assert.AreEqual ("123", Convert.ToString(tryByte, ci), "#O18");
1978                         Assert.AreEqual ("1111011", Convert.ToString(tryByte, 2), "#O19");
1979                         Assert.AreEqual ("173", Convert.ToString(tryByte, 8), "#O20");
1980                         Assert.AreEqual ("123", Convert.ToString(tryByte, 10), "#O21");
1981                         Assert.AreEqual ("7b", Convert.ToString(tryByte, 16), "#O22");
1982                         Assert.AreEqual ("a", Convert.ToString(tryChar, ci), "#O23");
1983                         Assert.AreEqual (tryDT.ToString(ci), Convert.ToString(tryDT, ci), "#O24");
1984                         Assert.AreEqual (tryDec.ToString(ci), Convert.ToString(tryDec, ci), "#O25");
1985                         Assert.AreEqual (tryDbl.ToString(ci), Convert.ToString(tryDbl, ci), "#O26");
1986                         Assert.AreEqual ("1234", Convert.ToString(tryInt16, ci), "#O27");
1987                         Assert.AreEqual ("10011010010", Convert.ToString(tryInt16, 2), "#O28");
1988                         Assert.AreEqual ("2322", Convert.ToString(tryInt16, 8), "#O29");
1989                         Assert.AreEqual ("1234", Convert.ToString(tryInt16, 10), "#O30");
1990                         Assert.AreEqual ("4d2", Convert.ToString(tryInt16, 16), "#O31");
1991                         Assert.AreEqual ("12345", Convert.ToString(tryInt32, ci), "#O32");
1992                         Assert.AreEqual ("11000000111001", Convert.ToString(tryInt32, 2), "#O33");
1993                         Assert.AreEqual ("30071", Convert.ToString(tryInt32, 8), "#O34");
1994                         Assert.AreEqual ("12345", Convert.ToString(tryInt32, 10), "#O35");
1995                         Assert.AreEqual ("3039", Convert.ToString(tryInt32, 16), "#O36");
1996                         Assert.AreEqual ("123456789012", Convert.ToString(tryInt64, ci), "#O37");
1997                         Assert.AreEqual ("1110010111110100110010001101000010100", Convert.ToString(tryInt64, 2), "#O38");
1998                         Assert.AreEqual ("1627646215024", Convert.ToString(tryInt64, 8), "#O39");
1999                         Assert.AreEqual ("123456789012", Convert.ToString(tryInt64, 10), "#O40");
2000                         Assert.AreEqual ("1cbe991a14", Convert.ToString(tryInt64, 16), "#O41");
2001                         Assert.AreEqual ("123", Convert.ToString((trySByte), ci), "#O42");
2002                         Assert.AreEqual (tryFloat.ToString(ci), Convert.ToString((tryFloat), ci), "#O43");
2003                         Assert.AreEqual ("foobar", Convert.ToString((tryStr), ci), "#O44");
2004                         Assert.AreEqual ("34567", Convert.ToString((tryUI16), ci), "#O45");
2005                         Assert.AreEqual ("567891234", Convert.ToString((tryUI32), ci), "#O46");
2006                         Assert.AreEqual ("0", Convert.ToString(tryUI64), "#O47");
2007                         Assert.AreEqual ("0", Convert.ToString((tryUI64), ci), "#O48");
2008
2009                         try {
2010                                 Convert.ToString(tryInt16, 5);
2011                                 Assert.Fail ();
2012                         }
2013                         catch (Exception e) {
2014                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#O55");
2015                         }
2016
2017                         try {
2018                                 Convert.ToString(tryInt32, 17);
2019                                 Assert.Fail ();
2020                         }
2021                         catch (Exception e) {
2022                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#O56");
2023                         }
2024
2025                         try {
2026                                 Convert.ToString(tryInt64, 1);
2027                                 Assert.Fail ();
2028                         }
2029                         catch (Exception e) {
2030                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#O57");
2031                         }
2032                 }
2033
2034                 public void TestToUInt16() {
2035                         Assert.AreEqual ((ushort)0, Convert.ToUInt16(boolFalse), "#P01");
2036                         Assert.AreEqual ((ushort)1, Convert.ToUInt16(boolTrue), "#P02");
2037                         Assert.AreEqual ((ushort)0, Convert.ToUInt16(tryByte), "#P03");
2038                         Assert.AreEqual ((ushort)97, Convert.ToUInt16(tryChar), "#P04");
2039                         Assert.AreEqual ((ushort)1234, Convert.ToUInt16(tryDec), "#P05");
2040                         Assert.AreEqual ((ushort)0, Convert.ToUInt16(tryDbl), "#P06");
2041                         Assert.AreEqual ((ushort)1234, Convert.ToUInt16(tryInt16), "#P07");
2042                         Assert.AreEqual ((ushort)12345, Convert.ToUInt16(tryInt32), "#P08");
2043                         Assert.AreEqual ((ushort)43752, Convert.ToUInt16((long)43752), "#P09");
2044                         Assert.AreEqual ((ushort)123, Convert.ToUInt16(trySByte), "#P10");
2045                         Assert.AreEqual ((ushort)1234, Convert.ToUInt16(tryFloat), "#P11");
2046                         Assert.AreEqual ((ushort)123, Convert.ToUInt16((string)"123"), "#P12");
2047                         Assert.AreEqual ((ushort)34567, Convert.ToUInt16(tryUI16), "#P13");
2048                         Assert.AreEqual ((ushort)56789, Convert.ToUInt16((uint)56789), "#P14");
2049                         Assert.AreEqual ((ushort)0, Convert.ToUInt16(tryUI64), "#P15");
2050                         Assert.AreEqual ((ushort)31, Convert.ToUInt16("31", ci), "#P16");
2051                         Assert.AreEqual ((ushort)14, Convert.ToUInt16("1110", 2), "#P17");
2052                         Assert.AreEqual ((ushort)32, Convert.ToUInt16("40", 8), "#P18");
2053                         Assert.AreEqual ((ushort)40, Convert.ToUInt16("40", 10), "#P19");
2054                         Assert.AreEqual ((ushort)64, Convert.ToUInt16("40", 16), "#P20");
2055
2056
2057                         try {
2058                                 Convert.ToUInt16(tryDT);
2059                                 Assert.Fail ();
2060                         }
2061                         catch (Exception e) {
2062                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#P25");
2063                         }
2064
2065                         try {
2066                                 Convert.ToUInt16(decimal.MaxValue);
2067                                 Assert.Fail ();
2068                         }
2069                         catch (Exception e) {
2070                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P26");
2071                         }
2072
2073                         try {
2074                                 Convert.ToUInt16(decimal.MinValue);
2075                                 Assert.Fail ();
2076                         }
2077                         catch (Exception e) {
2078                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P27");
2079                         }
2080
2081                         try {
2082                                 Convert.ToUInt16(double.MaxValue);
2083                                 Assert.Fail ();
2084                         }
2085                         catch (Exception e) {
2086                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P28");
2087                         }
2088
2089                         try {
2090                                 Convert.ToUInt16(double.MinValue);
2091                                 Assert.Fail ();
2092                         }
2093                         catch (Exception e) {
2094                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P29");
2095                         }
2096
2097                         try {
2098                                 Convert.ToUInt16(short.MinValue);
2099                                 Assert.Fail ();
2100                         }
2101                         catch (Exception e) {
2102                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P30");
2103                         }
2104
2105                         try {
2106                                 Convert.ToUInt16(int.MaxValue);
2107                                 Assert.Fail ();
2108                         }
2109                         catch (Exception e) {
2110                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P31");
2111                         }
2112
2113                         try {
2114                                 Convert.ToUInt16(int.MinValue);
2115                                 Assert.Fail ();
2116                         }
2117                         catch (Exception e) {
2118                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P32");
2119                         }
2120
2121                         try {
2122                                 Convert.ToUInt16(long.MaxValue);
2123                                 Assert.Fail ();
2124                         }
2125                         catch (Exception e) {
2126                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P33");
2127                         }
2128
2129                         try {
2130                                 Convert.ToUInt16(long.MinValue);
2131                                 Assert.Fail ();
2132                         }
2133                         catch (Exception e) {
2134                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P34");
2135                         }
2136
2137                         try {
2138                                 Convert.ToUInt16(tryObj);
2139                                 Assert.Fail ();
2140                         }
2141                         catch (Exception e) {
2142                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#P35");
2143                         }
2144
2145                         try {
2146                                 Convert.ToUInt16(sbyte.MinValue);
2147                                 Assert.Fail ();
2148                         }
2149                         catch (Exception e) {
2150                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P36");
2151                         }
2152
2153                         try {
2154                                 Convert.ToUInt16(float.MaxValue);
2155                                 Assert.Fail ();
2156                         }
2157                         catch (Exception e) {
2158                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P37");
2159                         }
2160
2161                         try {
2162                                 Convert.ToUInt16(float.MinValue);
2163                                 Assert.Fail ();
2164                         }
2165                         catch (Exception e) {
2166                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P38");
2167                         }
2168
2169                         try {
2170                                 Convert.ToUInt16("1A2");
2171                                 Assert.Fail ();
2172                         }
2173                         catch (Exception e) {
2174                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#P39");
2175                         }
2176
2177                         try {
2178                                 Convert.ToUInt16("-32800");
2179                                 Assert.Fail ();
2180                         }
2181                         catch (Exception e) {
2182                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P40");
2183                         }
2184
2185                         try {
2186                                 Convert.ToUInt16(int.MaxValue.ToString());
2187                                 Assert.Fail ();
2188                         }
2189                         catch (Exception e) {
2190                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P41");
2191                         }
2192
2193                         try {
2194                                 Convert.ToUInt16(ulong.MaxValue);
2195                                 Assert.Fail ();
2196                         }
2197                         catch (Exception e) {
2198                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P42");
2199                         }
2200
2201                         try {
2202                                 Convert.ToUInt16("1A2", ci);
2203                                 Assert.Fail ();
2204                         }
2205                         catch (Exception e) {
2206                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#P43");
2207                         }
2208
2209                         try {
2210                                 Convert.ToUInt16("-32800", ci);
2211                                 Assert.Fail ();
2212                         }
2213                         catch (Exception e) {
2214                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P44");
2215                         }
2216
2217                         try {
2218                                 Convert.ToUInt16("456987", ci);
2219                                 Assert.Fail ();
2220                         }
2221                         catch (Exception e) {
2222                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#P45");
2223                         }
2224
2225                         try {
2226                                 Convert.ToUInt16("40", 9);
2227                                 Assert.Fail ();
2228                         }
2229                         catch (Exception e) {
2230                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#P46");
2231                         }
2232
2233                         try {
2234                                 Convert.ToUInt16 ("abcde", 16);
2235                                 Assert.Fail ();
2236                         }
2237                         catch (Exception e) {
2238                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#P47");
2239                         }
2240                 }
2241
2242                 public void TestSignedToInt() {
2243                   //  String cannot contain a minus sign if the base is not 10.
2244                   // But can if it is ten, and + is allowed everywhere.
2245                   Assert.AreEqual (-1, Convert.ToInt32 ("-1", 10), "Signed0");
2246                   Assert.AreEqual (1, Convert.ToInt32 ("+1", 10), "Signed1");
2247                   Assert.AreEqual (1, Convert.ToInt32 ("+1", 2), "Signed2");
2248                   Assert.AreEqual (1, Convert.ToInt32 ("+1", 8), "Signed3");
2249                   Assert.AreEqual (1, Convert.ToInt32 ("+1", 16), "Signed4");
2250
2251                   try {
2252                         Convert.ToInt32("-1", 2);
2253                         Assert.Fail ();
2254                   }
2255                   catch (Exception) {
2256                   }
2257                   try {
2258                         Convert.ToInt32("-1", 8);
2259                         Assert.Fail ();
2260                   }
2261                   catch (Exception) {
2262                   }
2263                   try {
2264                         Convert.ToInt32("-1", 16);
2265                         Assert.Fail ();
2266                   }
2267                   catch (Exception) {
2268                   }
2269
2270
2271                 }
2272
2273                 public void TestToUInt32() {
2274                         Assert.AreEqual ((uint)1, Convert.ToUInt32(boolTrue), "#Q01");
2275                         Assert.AreEqual ((uint)0, Convert.ToUInt32(boolFalse), "#Q02");
2276                         Assert.AreEqual ((uint)0, Convert.ToUInt32(tryByte), "#Q03");
2277                         Assert.AreEqual ((uint)97, Convert.ToUInt32(tryChar), "#Q04");
2278                         Assert.AreEqual ((uint)1234, Convert.ToUInt32(tryDec), "#Q05");
2279                         Assert.AreEqual ((uint)0, Convert.ToUInt32(tryDbl), "#Q06");
2280                         Assert.AreEqual ((uint)1234, Convert.ToUInt32(tryInt16), "#Q07");
2281                         Assert.AreEqual ((uint)12345, Convert.ToUInt32(tryInt32), "#Q08");
2282                         Assert.AreEqual ((uint)1234567890, Convert.ToUInt32((long)1234567890), "#Q09");
2283                         Assert.AreEqual ((uint)123, Convert.ToUInt32(trySByte), "#Q10");
2284                         Assert.AreEqual ((uint)1234, Convert.ToUInt32(tryFloat), "#Q11");
2285                         Assert.AreEqual ((uint)3456789, Convert.ToUInt32("3456789"), "#Q12");
2286                         Assert.AreEqual ((uint)34567, Convert.ToUInt32(tryUI16), "#Q13");
2287                         Assert.AreEqual ((uint)567891234, Convert.ToUInt32(tryUI32), "#Q14");
2288                         Assert.AreEqual ((uint)0, Convert.ToUInt32(tryUI64), "#Q15");
2289                         Assert.AreEqual ((uint)415, Convert.ToUInt32("110011111", 2), "#Q16");
2290                         Assert.AreEqual ((uint)156, Convert.ToUInt32("234", 8), "#Q17");
2291                         Assert.AreEqual ((uint)234, Convert.ToUInt32("234", 10), "#Q18");
2292                         Assert.AreEqual ((uint)564, Convert.ToUInt32("234", 16), "#Q19");
2293
2294
2295                         try {
2296                                 Convert.ToUInt32(tryDT);
2297                                 Assert.Fail ();
2298                         }
2299                         catch (Exception e) {
2300                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#Q25");
2301                         }
2302
2303                         try {
2304                                 Convert.ToUInt32(decimal.MaxValue);
2305                                 Assert.Fail ();
2306                         }
2307                         catch (Exception e) {
2308                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q26");
2309                         }
2310
2311                         try {
2312                                 Convert.ToUInt32((decimal)-150);
2313                                 Assert.Fail ();
2314                         }
2315                         catch (Exception e) {
2316                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q27");
2317                         }
2318
2319                         try {
2320                                 Convert.ToUInt32(double.MaxValue);
2321                                 Assert.Fail ();
2322                         }
2323                         catch (Exception e) {
2324                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q28");
2325                         }
2326
2327                         try {
2328                                 Convert.ToUInt32((double)-1);
2329                                 Assert.Fail ();
2330                         }
2331                         catch (Exception e) {
2332                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q29");
2333                         }
2334
2335                         try {
2336                                 Convert.ToUInt32(short.MinValue);
2337                                 Assert.Fail ();
2338                         }
2339                         catch (Exception e) {
2340                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q30");
2341                         }
2342
2343                         try {
2344                                 Convert.ToUInt32(int.MinValue);
2345                                 Assert.Fail ();
2346                         }
2347                         catch (Exception e) {
2348                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q31");
2349                         }
2350
2351                         try {
2352                                 Convert.ToUInt32(long.MaxValue);
2353                                 Assert.Fail ();
2354                         }
2355                         catch (Exception e) {
2356                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q32");
2357                         }
2358
2359                         try {
2360                                 Convert.ToUInt32((long)-50000);
2361                                 Assert.Fail ();
2362                         }
2363                         catch (Exception e) {
2364                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q33");
2365                         }
2366
2367                         try {
2368                                 Convert.ToUInt32(new Exception());
2369                                 Assert.Fail ();
2370                         }
2371                         catch (Exception e) {
2372                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#Q34");
2373                         }
2374
2375                         try {
2376                                 Convert.ToUInt32(sbyte.MinValue);
2377                                 Assert.Fail ();
2378                         }
2379                         catch (Exception e) {
2380                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q35");
2381                         }
2382
2383                         try {
2384                                 Convert.ToUInt32(float.MaxValue);
2385                                 Assert.Fail ();
2386                         }
2387                         catch (Exception e) {
2388                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q36");
2389                         }
2390
2391                         try {
2392                                 Convert.ToUInt32(float.MinValue);
2393                                 Assert.Fail ();
2394                         }
2395                         catch (Exception e) {
2396                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q37");
2397                         }
2398
2399                         try {
2400                                 Convert.ToUInt32("45t54");
2401                                 Assert.Fail ();
2402                         }
2403                         catch (Exception e) {
2404                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#Q38");
2405                         }
2406
2407                         try {
2408                                 Convert.ToUInt32("-55");
2409                                 Assert.Fail ();
2410                         }
2411                         catch (Exception e) {
2412                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q39");
2413                         }
2414
2415                         try {
2416                                 Convert.ToUInt32(ulong.MaxValue);
2417                                 Assert.Fail ();
2418                         }
2419                         catch (Exception e) {
2420                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q40");
2421                         }
2422
2423                         try {
2424                                 Convert.ToUInt32(new Exception(), ci);
2425                                 Assert.Fail ();
2426                         }
2427                         catch (Exception e) {
2428                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#Q41");
2429                         }
2430
2431                         try {
2432                                 Convert.ToUInt32(tryStr, ci);
2433                                 Assert.Fail ();
2434                         }
2435                         catch (Exception e) {
2436                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#Q42");
2437                         }
2438
2439                         try {
2440                                 Convert.ToUInt32("-50", ci);
2441                                 Assert.Fail ();
2442                         }
2443                         catch (Exception e) {
2444                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q43");
2445                         }
2446
2447                         try {
2448                                 Convert.ToUInt32(decimal.MaxValue.ToString(), ci);
2449                                 Assert.Fail ();
2450                         }
2451                         catch (Exception e) {
2452                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#Q44");
2453                         }
2454
2455                         try {
2456                                 Convert.ToUInt32("1001110", 1);
2457                                 Assert.Fail ();
2458                         }
2459                         catch (Exception e) {
2460                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#Q45");
2461                         }
2462                 }
2463
2464                 public void TestToUInt64()
2465                 {
2466                         int iTest = 1;
2467                         try {
2468                                 Assert.AreEqual ((ulong)1, Convert.ToUInt64(boolTrue), "#R01");
2469                                 iTest++;
2470                                 Assert.AreEqual ((ulong)0, Convert.ToUInt64(boolFalse), "#R02");
2471                                 iTest++;
2472                                 Assert.AreEqual ((ulong)0, Convert.ToUInt64(tryByte), "#R03");
2473                                 iTest++;
2474                                 Assert.AreEqual ((ulong)97, Convert.ToUInt64(tryChar), "#R04");
2475                                 iTest++;
2476                                 Assert.AreEqual ((ulong)1234, Convert.ToUInt64(tryDec), "#R05");
2477                                 iTest++;
2478                                 Assert.AreEqual ((ulong)0, Convert.ToUInt64(tryDbl), "#R06");
2479                                 iTest++;
2480                                 Assert.AreEqual ((ulong)1234, Convert.ToUInt64(tryInt16), "#R07");
2481                                 iTest++;
2482                                 Assert.AreEqual ((ulong)12345, Convert.ToUInt64(tryInt32), "#R08");
2483                                 iTest++;
2484                                 Assert.AreEqual ((ulong)123456789012, Convert.ToUInt64(tryInt64), "#R09");
2485                                 iTest++;
2486                                 Assert.AreEqual ((ulong)123, Convert.ToUInt64(trySByte), "#R10");
2487                                 iTest++;
2488                                 Assert.AreEqual ((ulong)1234, Convert.ToUInt64(tryFloat), "#R11");
2489                                 iTest++;
2490                                 Assert.AreEqual ((ulong)345678, Convert.ToUInt64("345678"), "#R12");
2491                                 iTest++;
2492                                 Assert.AreEqual ((ulong)34567, Convert.ToUInt64(tryUI16), "#R13");
2493                                 iTest++;
2494                                 Assert.AreEqual ((ulong)567891234, Convert.ToUInt64(tryUI32), "#R14");
2495                                 iTest++;
2496                                 Assert.AreEqual ((ulong)0, Convert.ToUInt64(tryUI64), "#R15");
2497                                 iTest++;
2498                                 Assert.AreEqual ((ulong)123, Convert.ToUInt64("123", ci), "#R16");
2499                                 iTest++;
2500                                 Assert.AreEqual ((ulong)4, Convert.ToUInt64("100", 2), "#R17");
2501                                 iTest++;
2502                                 Assert.AreEqual ((ulong)64, Convert.ToUInt64("100", 8), "#R18");
2503                                 iTest++;
2504                                 Assert.AreEqual ((ulong)100, Convert.ToUInt64("100", 10), "#R19");
2505                                 iTest++;
2506                                 Assert.AreEqual ((ulong)256, Convert.ToUInt64("100", 16), "#R20");
2507                         } catch (Exception e) {
2508                                 Assert.Fail ("Unexpected exception caught when iTest = " + iTest + ": e = " + e);
2509                         }
2510
2511                         try {
2512                                 Convert.ToUInt64(tryDT);
2513                                 Assert.Fail ();
2514                         }
2515                         catch (Exception e) {
2516                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#R25");
2517                         }
2518
2519                         try {
2520                                 Convert.ToUInt64(decimal.MaxValue);
2521                                 Assert.Fail ();
2522                         }
2523                         catch (Exception e) {
2524                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R26");
2525                         }
2526
2527                         try {
2528                                 Convert.ToUInt64((decimal)-140);
2529                                 Assert.Fail ();
2530                         }
2531                         catch (Exception e) {
2532                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R27");
2533                         }
2534
2535                         try {
2536                                 Convert.ToUInt64(double.MaxValue);
2537                                 Assert.Fail ();
2538                         }
2539                         catch (Exception e) {
2540                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R28");
2541                         }
2542
2543                         try {
2544                                 Convert.ToUInt64((double)-1);
2545                                 Assert.Fail ();
2546                         }
2547                         catch (Exception e) {
2548                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R29");
2549                         }
2550
2551                         try {
2552                                 Convert.ToUInt64(short.MinValue);
2553                                 Assert.Fail ();
2554                         }
2555                         catch (Exception e) {
2556                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R30");
2557                         }
2558
2559                         try {
2560                                 Convert.ToUInt64(int.MinValue);
2561                                 Assert.Fail ();
2562                         }
2563                         catch (Exception e) {
2564                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R31");
2565                         }
2566
2567                         try {
2568                                 Convert.ToUInt64(long.MinValue);
2569                                 Assert.Fail ();
2570                         }
2571                         catch (Exception e) {
2572                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R32");
2573                         }
2574
2575                         try {
2576                                 Convert.ToUInt64(tryObj);
2577                                 Assert.Fail ();
2578                         }
2579                         catch (Exception e) {
2580                                 Assert.AreEqual (typeof(InvalidCastException), e.GetType(), "#R33");
2581                         }
2582
2583                         try {
2584                                 Convert.ToUInt64(sbyte.MinValue);
2585                                 Assert.Fail ();
2586                         }
2587                         catch (Exception e) {
2588                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R34");
2589                         }
2590
2591                         try {
2592                                 Convert.ToUInt64(float.MinValue);
2593                                 Assert.Fail ();
2594                         }
2595                         catch (Exception e) {
2596                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R35");
2597                         }
2598
2599                         try {
2600                                 Convert.ToUInt64(float.MaxValue);
2601                                 Assert.Fail ();
2602                         }
2603                         catch (Exception e) {
2604                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R36");
2605                         }
2606
2607                         try {
2608                                 Convert.ToUInt64("234rt78");
2609                                 Assert.Fail ();
2610                         }
2611                         catch (Exception e) {
2612                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#R37");
2613                         }
2614
2615                         try {
2616                                 Convert.ToUInt64("-68");
2617                                 Assert.Fail ();
2618                         }
2619                         catch (Exception e) {
2620                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R38");
2621                         }
2622
2623                         try {
2624                                 Convert.ToUInt64(decimal.MaxValue.ToString());
2625                                 Assert.Fail ();
2626                         }
2627                         catch (Exception e) {
2628                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R39");
2629                         }
2630
2631                         try {
2632                                 Convert.ToUInt64("23rd2", ci);
2633                                 Assert.Fail ();
2634                         }
2635                         catch (Exception e) {
2636                                 Assert.AreEqual (typeof(FormatException), e.GetType(), "#R40");
2637                         }
2638
2639                         try {
2640                                 Convert.ToUInt64(decimal.MinValue.ToString(), ci);
2641                                 Assert.Fail ();
2642                         }
2643                         catch (Exception e) {
2644                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R41");
2645                         }
2646
2647                         try {
2648                                 Convert.ToUInt64(decimal.MaxValue.ToString(), ci);
2649                                 Assert.Fail ();
2650                         }
2651                         catch (Exception e) {
2652                                 Assert.AreEqual (typeof(OverflowException), e.GetType(), "#R42");
2653                         }
2654
2655                         try {
2656                                 Convert.ToUInt64("132", 9);
2657                                 Assert.Fail ();
2658                         }
2659                         catch (Exception e) {
2660                                 Assert.AreEqual (typeof(ArgumentException), e.GetType(), "#R43");
2661                         }
2662
2663
2664                         Assert.AreEqual ((ulong) 256, Convert.ToUInt64 ("0x100", 16), "#L35");
2665                         Assert.AreEqual ((ulong) 256, Convert.ToUInt64 ("0X100", 16), "#L36");
2666                         Assert.AreEqual (ulong.MaxValue, Convert.ToUInt64 ("0xFFFFFFFFFFFFFFFF", 16), "#L37");
2667                 }
2668
2669                 [Test]
2670                 [ExpectedException (typeof (FormatException))]
2671                 public void TestInvalidBase64() {
2672                   // This has to be a multiple of 4 characters, otherwise you
2673                   // are testing something else. Ideally one will become a byte
2674                   // > 128
2675                   //
2676                   // This test is designed to see what happens with invalid bytes
2677                   string brokenB64 = "AB~\u00a3";
2678                   Convert.FromBase64String(brokenB64);
2679                 }
2680
2681                 [Test] // bug #5464
2682                 [ExpectedException (typeof (FormatException))]
2683                 public void TestInvalidBase64_Bug5464 ()
2684                 {
2685                         Convert.FromBase64String ("dGVzdA==DQo=");
2686                 }
2687
2688                 [Test] // bug #5464
2689                 public void TestValidBase64_Bug5464 ()
2690                 {
2691                         byte[] result = Convert.FromBase64String ("dGVzdA==");
2692                         Assert.AreEqual(4, result.Length, "Array.Length expected to be 4.");
2693                         Assert.AreEqual(116, result[0], "#A01");
2694                         Assert.AreEqual(101, result[1], "#A02");
2695                         Assert.AreEqual(115, result[2], "#A03");
2696                         Assert.AreEqual(116, result[3], "#A04");
2697                 }
2698
2699                 [Test]
2700                 [ExpectedException (typeof (FormatException))]
2701                 public void TestInvalidBase64_TooManyPaddings ()
2702                 {
2703                         Convert.FromBase64String ("dGVzd===");
2704                 }
2705
2706                 [Test]
2707                 public void TestBeginWithSpaces ()
2708                 {
2709                         byte[] bb = new byte[] { 1, 2, 3};
2710                         string s = Convert.ToBase64String (bb);
2711                         byte [] b2 = Convert.FromBase64String ("     " + s);
2712                         Assert.AreEqual (3, b2.Length, "#01");
2713                         for (int i = 0; i < 3; i++)
2714                                 Assert.AreEqual (bb [i], b2 [i], "#0" + (i + 2));
2715                 }
2716
2717                 public void TestToBase64CharArray ()
2718                 {
2719                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2720                         //                                                 0    1        2        3    4        5        6        7
2721                         char[] expectedCharArr = {'I', 'X', '/', '/', 'b', 'a', 'o', '2'};
2722                         char[] result = new Char[8];
2723
2724                         Convert.ToBase64CharArray(byteArr, 0, byteArr.Length, result, 0);
2725
2726                         for (int i = 0; i < expectedCharArr.Length; i++) {
2727                                 Assert.AreEqual (expectedCharArr[i], result[i], "#S0" + i);
2728                         }
2729                 }
2730
2731                 [Test]
2732                 [ExpectedException (typeof(ArgumentNullException))]
2733                 public void ToBase64CharArray_InNull ()
2734                 {
2735                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2736                         char[] result = new Char[8];
2737                         Convert.ToBase64CharArray (null, 0, byteArr.Length, result, 0);
2738                 }
2739
2740                 [Test]
2741                 [ExpectedException (typeof(ArgumentNullException))]
2742                 public void ToBase64CharArray_OutNull ()
2743                 {
2744                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2745                         Convert.ToBase64CharArray (byteArr, 0, byteArr.Length, null, 0);
2746                 }
2747
2748                 [Test]
2749                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2750                 public void ToBase64CharArray_OffsetInNegative ()
2751                 {
2752                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2753                         char[] result = new Char[8];
2754                         Convert.ToBase64CharArray (byteArr, -1, byteArr.Length, result, 0);
2755                 }
2756
2757                 [Test]
2758                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2759                 public void ToBase64CharArray_LengthNegative ()
2760                 {
2761                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2762                         char[] result = new Char[8];
2763                         Convert.ToBase64CharArray (byteArr, 0, -5, result, 0);
2764                 }
2765
2766                 [Test]
2767                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2768                 public void ToBase64CharArray_OffsetOutNegative ()
2769                 {
2770                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2771                         char[] result = new Char[8];
2772                         Convert.ToBase64CharArray (byteArr, 0, byteArr.Length, result, -2);
2773                 }
2774
2775                 [Test]
2776                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2777                 public void ToBase64CharArray_TotalIn ()
2778                 {
2779                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2780                         char[] result = new Char[8];
2781                         Convert.ToBase64CharArray (byteArr, 4, byteArr.Length, result, 0);
2782                 }
2783
2784                 [Test]
2785                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2786                 public void ToBase64CharArray_TotalInOverflow ()
2787                 {
2788                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2789                         char[] result = new Char[8];
2790                         Convert.ToBase64CharArray (byteArr, Int32.MaxValue, byteArr.Length, result, 0);
2791                 }
2792
2793                 [Test]
2794                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2795                 public void ToBase64CharArray_TotalOut ()
2796                 {
2797                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2798                         char[] result = new Char[8];
2799                         Convert.ToBase64CharArray (byteArr, 0, byteArr.Length, result, 2);
2800                 }
2801
2802                 [Test]
2803                 [ExpectedException (typeof(ArgumentOutOfRangeException))]
2804                 public void ToBase64CharArray_TotalOutOverflow ()
2805                 {
2806                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2807                         char[] result = new Char[8];
2808                         Convert.ToBase64CharArray (byteArr, 0, byteArr.Length, result, Int32.MaxValue);
2809                 }
2810
2811                 public void TestToBase64String() {
2812                         byte[] byteArr = {33, 127, 255, 109, 170, 54};
2813                         string expectedStr = "IX//bao2";
2814                         string result1;
2815                         string result2;
2816
2817                         result1 = Convert.ToBase64String(byteArr);
2818                         result2 = Convert.ToBase64String(byteArr, 0, byteArr.Length);
2819
2820                         Assert.AreEqual (expectedStr, result1, "#T01");
2821                         Assert.AreEqual (expectedStr, result2, "#T02");
2822
2823                         try {
2824                                 Convert.ToBase64String(null);
2825                                 Assert.Fail ();
2826                         }
2827                         catch (Exception e) {
2828                                 Assert.AreEqual (typeof(ArgumentNullException), e.GetType(), "#T05");
2829                         }
2830
2831                         try {
2832                                 Convert.ToBase64String(byteArr, -1, byteArr.Length);
2833                                 Assert.Fail ();
2834                         }
2835                         catch (Exception e) {
2836                                 Assert.AreEqual (typeof(ArgumentOutOfRangeException), e.GetType(), "#T06");
2837                         }
2838
2839                         try {
2840                                 Convert.ToBase64String(byteArr, 0, -10);
2841                                 Assert.Fail ();
2842                         }
2843                         catch (Exception e) {
2844                                 Assert.AreEqual (typeof(ArgumentOutOfRangeException), e.GetType(), "#T07");
2845                         }
2846
2847                         try {
2848                                 Convert.ToBase64String(byteArr, 4, byteArr.Length);
2849                                 Assert.Fail ();
2850                         }
2851                         catch (Exception e) {
2852                                 Assert.AreEqual (typeof(ArgumentOutOfRangeException), e.GetType(), "#T08");
2853                         }
2854                 }
2855 #if NET_2_0
2856                 [Test]
2857                 public void ToBase64String_Bug76876 ()
2858                 {
2859                         byte[] bs = Convert.FromBase64String ("ZuBZ7PESb3VRXgrl/KSRJd/hTGBvaEvEplqH3izPomDv5nBjS9MzcD1h8tOWzS7/wYGnaip8\nbhBfCrpWxivi8G7R08oBcADIiclpZeqRxai9kG4WoBUzJ6MCbxuvb1k757q+D9nqoL0p9Rer\n+5+vNodYkHYwqnKKyMBSQ11sspw=\n");
2860                         string s = Convert.ToBase64String (bs, Base64FormattingOptions.None);
2861                         Assert.IsTrue (!s.Contains ("\n"), "no new line");
2862                 }
2863
2864                 static string ToBase64 (int len, Base64FormattingOptions options)
2865                 {
2866                         return Convert.ToBase64String (new byte [len], options);
2867                 }
2868
2869                 [Test]
2870                 public void Base64String_LineEnds_InsertLineBreaks ()
2871                 {
2872                         string base64 = ToBase64 (0, Base64FormattingOptions.InsertLineBreaks);
2873                         Assert.IsFalse (base64.EndsWith (Environment.NewLine), "0-le");
2874                         Assert.AreEqual (String.Empty, base64, "0");
2875
2876                         base64 = ToBase64 (1, Base64FormattingOptions.InsertLineBreaks);
2877                         Assert.IsFalse (base64.EndsWith (Environment.NewLine), "1-le");
2878                         Assert.AreEqual ("AA==", base64, "1");
2879
2880                         base64 = ToBase64 (57, Base64FormattingOptions.InsertLineBreaks);
2881                         Assert.IsFalse (base64.Contains (Environment.NewLine), "57-nl"); // one lines
2882                         Assert.IsFalse (base64.EndsWith (Environment.NewLine), "57-le");
2883                         Assert.AreEqual ("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", base64, "55");
2884
2885                         base64 = ToBase64 (58, Base64FormattingOptions.InsertLineBreaks);
2886                         Assert.IsTrue (base64.Contains (Environment.NewLine), "58-nl"); // two lines
2887                         Assert.IsTrue (base64.EndsWith ("AA=="), "58-le"); // no NewLine
2888                 }
2889
2890                 [Test]
2891                 public void Base64String_LineEnds_None ()
2892                 {
2893                         string base64 = ToBase64 (0, Base64FormattingOptions.None);
2894                         Assert.IsFalse (base64.EndsWith (Environment.NewLine), "0-le");
2895                         Assert.AreEqual (String.Empty, base64, "0");
2896
2897                         base64 = ToBase64 (1, Base64FormattingOptions.None);
2898                         Assert.IsFalse (base64.EndsWith (Environment.NewLine), "1-le");
2899                         Assert.AreEqual ("AA==", base64, "1");
2900
2901                         base64 = ToBase64 (57, Base64FormattingOptions.None);
2902                         Assert.IsFalse (base64.Contains (Environment.NewLine), "57-nl"); // one lines
2903                         Assert.IsFalse (base64.EndsWith (Environment.NewLine), "57-le");
2904                         Assert.AreEqual ("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", base64, "55");
2905
2906                         base64 = ToBase64 (58, Base64FormattingOptions.None);
2907                         Assert.IsFalse (base64.Contains (Environment.NewLine), "58-nl"); // one lines
2908                         Assert.IsTrue (base64.EndsWith ("AA=="), "58-le"); // no NewLine
2909                 }
2910 #endif
2911                 /* Have experienced some problems with FromBase64CharArray using mono. Something
2912                  * about error in a unicode file.
2913                  *
2914                  * However the test seems to run fine using mono in a cygwin environment
2915                  */
2916
2917                 [Test]
2918                 [ExpectedException (typeof (ArgumentNullException))]
2919                 public void FromBase64CharArray_Null ()
2920                 {
2921                         Convert.FromBase64CharArray (null, 1, 5);
2922                 }
2923
2924                 [Test]
2925                 [ExpectedException (typeof (FormatException))]
2926                 [Category ("TargetJvmNotWorking")]
2927                 public void FromBase64CharArray_Empty ()
2928                 {
2929                         Convert.FromBase64CharArray (new char[0], 0, 0);
2930                 }
2931
2932                 [Test]
2933                 [ExpectedException (typeof (FormatException))]
2934                 [Category ("TargetJvmNotWorking")]
2935                 public void FormatBase64CharArray_OnlyWhitespace ()
2936                 {
2937                         Convert.FromBase64CharArray (new char[3] {' ',
2938                                 '\r', '\t'}, 0, 3);
2939                 }
2940
2941                 [Test]
2942                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2943                 public void FromBase64CharArray_OutOfRangeStart ()
2944                 {
2945                         Convert.FromBase64CharArray (new char [4], -1, 4);
2946                 }
2947
2948                 [Test]
2949                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2950                 public void FromBase64CharArray_OutOfRangeLength ()
2951                 {
2952                         Convert.FromBase64CharArray (new char [4], 2, 4);
2953                 }
2954
2955                 [Test]
2956                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
2957                 public void FromBase64CharArray_Overflow ()
2958                 {
2959                         Convert.FromBase64CharArray (new char [4], Int32.MaxValue, 4);
2960                 }
2961
2962                 [Test]
2963                 [ExpectedException (typeof (FormatException))]
2964                 public void FromBase64CharArray_InvalidLength ()
2965                 {
2966                         Convert.FromBase64CharArray (new char [4], 0, 3);
2967                 }
2968
2969                 [Test]
2970                 [ExpectedException (typeof (FormatException))]
2971                 public void FromBase64CharArray_WideChar ()
2972                 {
2973                         char[] c = new char [4] { 'A', 'A', 'A', (char) Char.MaxValue };
2974                         Convert.FromBase64CharArray (c, 0, 4);
2975                 }
2976
2977                 [Test]
2978                 public void FromBase64CharArray ()
2979                 {
2980                         char[] charArr = {'M','o','n','o','m','o','n','o'};
2981                         byte[] expectedByteArr = {50, 137, 232, 154, 137, 232};
2982
2983                         byte[] fromCharArr = Convert.FromBase64CharArray(charArr, 0, 8);
2984
2985                         for (int i = 0; i < fromCharArr.Length; i++){
2986                                 Assert.AreEqual (expectedByteArr[i], fromCharArr[i], "#U0" + i);
2987                         }
2988                 }
2989
2990                 /* Have experienced some problems with FromBase64String using mono. Something about
2991                  * error in a unicode file.
2992                  *
2993                  * However the test seems to run fine using mono in a cygwin environment
2994                  */
2995
2996                 [Test]
2997                 [ExpectedException (typeof (ArgumentNullException))]
2998                 public void FromBase64String_Null ()
2999                 {
3000                         Convert.FromBase64String (null);
3001                 }
3002
3003                 [Test]
3004                 [ExpectedException (typeof (FormatException))]
3005                 public void FromBase64String_InvalidLength ()
3006                 {
3007                         Convert.FromBase64String ("foo");
3008                 }
3009
3010                 [Test]
3011                 [ExpectedException (typeof (FormatException))]
3012                 public void FromBase64String_InvalidLength2 ()
3013                 {
3014                         Convert.FromBase64String (tryStr);
3015                 }
3016
3017                 [Test]
3018                 public void FromBase64String_InvalidLengthBecauseOfIgnoredChars ()
3019                 {
3020                         byte[] result = Convert.FromBase64String ("AAAA\t");
3021                         Assert.AreEqual (3, result.Length, "InvalidLengthBecauseOfIgnoredChars");
3022                 }
3023
3024                 private const string ignored = "\t\r\n ";
3025                 private const string base64data = "AAAAAAAAAAAAAAAAAAAA"; // 15 bytes 0x00
3026
3027                 [Test]
3028                 public void FromBase64_IgnoreCharsBefore ()
3029                 {
3030                         string s = ignored + base64data;
3031                         byte[] data = Convert.FromBase64String (s);
3032                         Assert.AreEqual (15, data.Length, "String-IgnoreCharsBefore-Ignored");
3033
3034                         char[] c = s.ToCharArray ();
3035                         data = Convert.FromBase64CharArray (c, 0, c.Length);
3036                         Assert.AreEqual (15, data.Length, "CharArray-IgnoreCharsBefore-Ignored");
3037                 }
3038
3039                 [Test]
3040                 public void FromBase64_IgnoreCharsInside ()
3041                 {
3042                         string s = base64data + ignored + base64data;
3043                         byte[] data = Convert.FromBase64String (s);
3044                         Assert.AreEqual (30, data.Length, "String-IgnoreCharsInside-Ignored");
3045
3046                         char[] c = s.ToCharArray ();
3047                         data = Convert.FromBase64CharArray (c, 0, c.Length);
3048                         Assert.AreEqual (30, data.Length, "CharArray-IgnoreCharsInside-Ignored");
3049                 }
3050
3051                 [Test]
3052                 public void FromBase64_IgnoreCharsAfter ()
3053                 {
3054                         string s = base64data + ignored;
3055                         byte[] data = Convert.FromBase64String (s);
3056                         Assert.AreEqual (15, data.Length, "String-IgnoreCharsAfter-Ignored");
3057
3058                         char[] c = s.ToCharArray ();
3059                         data = Convert.FromBase64CharArray (c, 0, c.Length);
3060                         Assert.AreEqual (15, data.Length, "CharArray-IgnoreCharsAfter-Ignored");
3061                 }
3062
3063                 [Test]
3064                 [Category ("TargetJvmNotWorking")]
3065                 public void FromBase64_Empty ()
3066                 {
3067                         Assert.AreEqual (new byte[0], Convert.FromBase64String (string.Empty));
3068                 }
3069
3070                 [Test]
3071 #if !NET_2_0
3072                 [ExpectedException (typeof (FormatException))]
3073 #endif
3074                 public void FromBase64_OnlyWhiteSpace ()
3075                 {
3076 #if NET_2_0
3077                         Assert.AreEqual (new byte[0], Convert.FromBase64String ("  \r\t"));
3078 #else
3079                         Convert.FromBase64String ("  \r\t");
3080 #endif
3081                 }
3082
3083                 [Test]
3084                 [ExpectedException (typeof (FormatException))]
3085                 public void FromBase64_InvalidChar ()
3086                 {
3087                         Convert.FromBase64String ("amVsb3U=\u0100");
3088                 }
3089
3090                 [Test]
3091                 [ExpectedException (typeof (FormatException))]
3092                 public void FromBase64_Min ()
3093                 {
3094                         Convert.FromBase64String ("amVsb3U=   \r \n\u007B");
3095                 }
3096
3097                 [Test]
3098                 public void FromBase64_TrailingEqualAndSpaces () // From bug #75840.
3099                 {
3100                         string base64 = "\n     fdy6S2NLpnT4fMdokUHSHsmpcvo=    ";
3101                         byte [] bytes = Convert.FromBase64String (base64);
3102                         Assert.AreEqual (20, bytes.Length, "#01");
3103                         byte [] target = new byte [] { 0x7D, 0xDC, 0xBA, 0x4B, 0x63, 0x4B, 0xA6, 0x74, 0xF8, 0x7C, 0xC7,
3104                                                         0x68, 0x91, 0x41, 0xD2, 0x1E, 0xC9, 0xA9, 0x72, 0xFA };
3105
3106                         for (int i = 0; i < 20; i++) {
3107                                 if (bytes [i] != target [i])
3108                                         Assert.Fail ("Item #" + i);
3109                         }
3110                 }
3111
3112                 public void TestConvertFromNull() {
3113
3114                         Assert.AreEqual (false, Convert.ToBoolean (null as object), "#W1");
3115                         Assert.AreEqual (0, Convert.ToByte (null as object), "#W2");
3116                         Assert.AreEqual (0, Convert.ToChar (null as object), "#W3");
3117                         Assert.AreEqual (new DateTime (1, 1, 1, 0, 0, 0), Convert.ToDateTime (null as object), "#W4");
3118                         Assert.AreEqual (0, Convert.ToDecimal (null as object), "#W5");
3119                         Assert.AreEqual (0, Convert.ToDouble (null as object), "#W6");
3120                         Assert.AreEqual (0, Convert.ToInt16 (null as object), "#W7");
3121                         Assert.AreEqual (0, Convert.ToInt32 (null as object), "#W8");
3122                         Assert.AreEqual (0, Convert.ToInt64 (null as object), "#W9");
3123                         Assert.AreEqual (0, Convert.ToSByte (null as object), "#W10");
3124                         Assert.AreEqual (0, Convert.ToSingle (null as object), "#W11");
3125                         Assert.AreEqual ("", Convert.ToString (null as object), "#W12");
3126                         Assert.AreEqual (0, Convert.ToUInt16 (null as object), "#W13");
3127                         Assert.AreEqual (0, Convert.ToUInt32 (null as object), "#W14");
3128                         Assert.AreEqual (0, Convert.ToUInt64 (null as object), "#W15");
3129                         Assert.AreEqual (false, Convert.ToBoolean (null as string), "#W16");
3130                         Assert.AreEqual (0, Convert.ToByte (null as string), "#W17");
3131
3132                         try {
3133                                 Convert.ToChar (null as string);
3134                                 Assert.Fail ();
3135                         } catch (Exception e) {
3136                                 Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "#W18");
3137                         }
3138
3139                         Assert.AreEqual (new DateTime (1, 1, 1, 0, 0, 0), Convert.ToDateTime (null as string), "#W19");
3140                         Assert.AreEqual (0, Convert.ToDecimal (null as string), "#W20");
3141                         Assert.AreEqual (0, Convert.ToDouble (null as string), "#W21");
3142                         Assert.AreEqual (0, Convert.ToInt16 (null as string), "#W22");
3143                         Assert.AreEqual (0, Convert.ToInt32 (null as string), "#W23");
3144                         Assert.AreEqual (0, Convert.ToInt64 (null as string), "#W24");
3145                         Assert.AreEqual (0, Convert.ToSByte (null as string), "#W25");
3146                         Assert.AreEqual (0, Convert.ToSingle (null as string), "#W26");
3147                         Assert.AreEqual (null, Convert.ToString (null as string), "#W27");
3148                         Assert.AreEqual (0, Convert.ToUInt16 (null as string), "#W28");
3149                         Assert.AreEqual (0, Convert.ToUInt32 (null as string), "#W29");
3150                         Assert.AreEqual (0, Convert.ToUInt64 (null as string), "#W30");
3151                 }
3152
3153                 [Test]
3154                 [ExpectedException (typeof (FormatException))]
3155                 public void FromBase64StringInvalidFormat ()
3156                 {
3157                         Convert.FromBase64String ("Tgtm+DBN====");
3158                 }
3159
3160                 [Test]
3161                 [ExpectedException (typeof (FormatException))]
3162                 public void FromBase64StringInvalidFormat2 ()
3163                 {
3164                         Convert.FromBase64String ("Tgtm+DBN========");
3165                 }
3166
3167                 [Test]
3168                 public void ToByte_PrefixedHexStringInBase16 ()
3169                 {
3170                         Assert.AreEqual (255, Convert.ToByte ("0xff", 16), "0xff");
3171                         Assert.AreEqual (255, Convert.ToByte ("0xfF", 16), "0xfF");
3172                         Assert.AreEqual (255, Convert.ToByte ("0xFf", 16), "0xFf");
3173                         Assert.AreEqual (255, Convert.ToByte ("0xFF", 16), "0xFF");
3174
3175                         Assert.AreEqual (255, Convert.ToByte ("0Xff", 16), "0Xff");
3176                         Assert.AreEqual (255, Convert.ToByte ("0XfF", 16), "0XfF");
3177                         Assert.AreEqual (255, Convert.ToByte ("0XFf", 16), "0XFf");
3178                         Assert.AreEqual (255, Convert.ToByte ("0XFF", 16), "0XFF");
3179
3180                         Assert.AreEqual (Byte.MinValue, Convert.ToByte ("0x0", 16), "0x0");
3181                 }
3182
3183                 [Test]
3184                 [ExpectedException (typeof (OverflowException))]
3185                 public void ToByte_NegativeString ()
3186                 {
3187                         Convert.ToByte ("-1");
3188                 }
3189
3190                 [Test]
3191                 [ExpectedException (typeof (ArgumentException))]
3192                 public void ToByte_NegativeStringNonBase10 ()
3193                 {
3194                         Convert.ToByte ("-0", 16);
3195                 }
3196
3197                 [Test]
3198                 [ExpectedException (typeof (OverflowException))]
3199                 public void ToByte_NegativeString_Base10 ()
3200                 {
3201                         Convert.ToByte ("-0", 10);
3202                 }
3203
3204                 [Test]
3205                 public void ToByte_NegativeZeroString ()
3206                 {
3207                         Convert.ToByte ("-0");
3208                         Convert.ToByte ("-0", null);
3209                 }
3210
3211                 [Test]
3212                 [ExpectedException (typeof (OverflowException))]
3213                 public void ToUInt16_NegativeString ()
3214                 {
3215                         Convert.ToUInt16 ("-1");
3216                 }
3217
3218                 [Test]
3219                 [ExpectedException (typeof (ArgumentException))]
3220                 public void ToUInt16_NegativeStringNonBase10 ()
3221                 {
3222                         Convert.ToUInt16 ("-0", 16);
3223                 }
3224
3225                 [Test]
3226                 [ExpectedException (typeof (OverflowException))]
3227                 public void ToUInt16_NegativeString_Base10 ()
3228                 {
3229                         Convert.ToUInt16 ("-0", 10);
3230                 }
3231
3232                 [Test]
3233                 public void ToUInt16_NegativeZeroString ()
3234                 {
3235                         Convert.ToUInt16 ("-0");
3236                         Convert.ToUInt16 ("-0", null);
3237                 }
3238
3239                 [Test]
3240                 [ExpectedException (typeof (OverflowException))]
3241                 public void ToUInt32_NegativeString ()
3242                 {
3243                         Convert.ToUInt32 ("-1");
3244                 }
3245
3246                 [Test]
3247                 [ExpectedException (typeof (ArgumentException))]
3248                 public void ToUInt32_NegativeStringNonBase10 ()
3249                 {
3250                         Convert.ToUInt32 ("-0", 16);
3251                 }
3252
3253                 [Test]
3254                 [ExpectedException (typeof (OverflowException))]
3255                 public void ToUInt32_NegativeString_Base10 ()
3256                 {
3257                         Convert.ToUInt32 ("-0", 10);
3258                 }
3259
3260                 [Test]
3261                 public void ToUInt32_NegativeZeroString ()
3262                 {
3263                         Convert.ToUInt32 ("-0");
3264                         Convert.ToUInt32 ("-0", null);
3265                 }
3266
3267                 [Test]
3268                 [ExpectedException (typeof (OverflowException))]
3269                 public void ToUInt64_NegativeString ()
3270                 {
3271                         Convert.ToUInt64 ("-1");
3272                 }
3273
3274                 [Test]
3275                 [ExpectedException (typeof (ArgumentException))]
3276                 public void ToUInt64_NegativeStringNonBase10 ()
3277                 {
3278                         Convert.ToUInt64 ("-0", 16);
3279                 }
3280
3281                 [Test]
3282                 [ExpectedException (typeof (OverflowException))]
3283                 public void ToUInt64_NegativeString_Base10 ()
3284                 {
3285                         Convert.ToUInt64 ("-0", 10);
3286                 }
3287
3288                 [Test]
3289                 public void ToUInt64_NegativeZeroString ()
3290                 {
3291                         Convert.ToUInt64 ("-0");
3292                         Convert.ToUInt64 ("-0", null);
3293                 }
3294
3295                 // min/max unsigned
3296
3297                 [Test]
3298                 public void ToByte_MaxValue ()
3299                 {
3300                         Assert.AreEqual (Byte.MaxValue, Convert.ToByte ("ff", 16), "ff,16");
3301                         Assert.AreEqual (Byte.MaxValue, Convert.ToByte ("0XFF", 16), "0xFF,16");
3302                         Assert.AreEqual (Byte.MaxValue, Convert.ToByte ("255", 10), "255,10");
3303                         Assert.AreEqual (Byte.MaxValue, Convert.ToByte ("377", 8), "377,8");
3304                         Assert.AreEqual (Byte.MaxValue, Convert.ToByte ("11111111", 2), "11111111,2");
3305                 }
3306
3307                 [Test]
3308                 public void ToByte_MinValue ()
3309                 {
3310                         Assert.AreEqual (Byte.MinValue, Convert.ToByte ("0", 16), "0,16");
3311                         Assert.AreEqual (Byte.MinValue, Convert.ToByte ("0x0", 16), "0x0,16");
3312                         Assert.AreEqual (Byte.MinValue, Convert.ToByte ("0", 10), "0,10");
3313                         Assert.AreEqual (Byte.MinValue, Convert.ToByte ("0", 8), "0,8");
3314                         Assert.AreEqual (Byte.MinValue, Convert.ToByte ("0", 2), "0,2");
3315                 }
3316
3317                 [Test]
3318                 public void ToUInt16_MaxValue ()
3319                 {
3320                         Assert.AreEqual (UInt16.MaxValue, Convert.ToUInt16 ("ffff", 16), "ffff,16");
3321                         Assert.AreEqual (UInt16.MaxValue, Convert.ToUInt16 ("0XFFFF", 16), "0XFFFF,16");
3322                         Assert.AreEqual (UInt16.MaxValue, Convert.ToUInt16 ("65535", 10), "65535,10");
3323                         Assert.AreEqual (UInt16.MaxValue, Convert.ToUInt16 ("177777", 8), "177777,8");
3324                         Assert.AreEqual (UInt16.MaxValue, Convert.ToUInt16 ("1111111111111111", 2), "1111111111111111,2");
3325                 }
3326
3327                 [Test]
3328                 public void ToUInt16_MinValue ()
3329                 {
3330                         Assert.AreEqual (UInt16.MinValue, Convert.ToUInt16 ("0", 16), "0,16");
3331                         Assert.AreEqual (UInt16.MinValue, Convert.ToUInt16 ("0x0", 16), "0x0,16");
3332                         Assert.AreEqual (UInt16.MinValue, Convert.ToUInt16 ("0", 10), "0,10");
3333                         Assert.AreEqual (UInt16.MinValue, Convert.ToUInt16 ("0", 8), "0,8");
3334                         Assert.AreEqual (UInt16.MinValue, Convert.ToUInt16 ("0", 2), "0,2");
3335                 }
3336
3337                 [Test]
3338                 public void ToUInt32_MaxValue ()
3339                 {
3340                         Assert.AreEqual (UInt32.MaxValue, Convert.ToUInt32 ("ffffffff", 16), "ffffffff,16");
3341                         Assert.AreEqual (UInt32.MaxValue, Convert.ToUInt32 ("0XFFFFFFFF", 16), "0XFFFFFFFF,16");
3342                         Assert.AreEqual (UInt32.MaxValue, Convert.ToUInt32 ("4294967295", 10), "4294967295,10");
3343                         Assert.AreEqual (UInt32.MaxValue, Convert.ToUInt32 ("37777777777", 8), "37777777777,8");
3344                         Assert.AreEqual (UInt32.MaxValue, Convert.ToUInt32 ("11111111111111111111111111111111", 2), "11111111111111111111111111111111,2");
3345                 }
3346
3347                 [Test]
3348                 public void ToUInt32_MinValue ()
3349                 {
3350                         Assert.AreEqual (UInt32.MinValue, Convert.ToUInt32 ("0", 16), "0,16");
3351                         Assert.AreEqual (UInt32.MinValue, Convert.ToUInt32 ("0x0", 16), "0x0,16");
3352                         Assert.AreEqual (UInt32.MinValue, Convert.ToUInt32 ("0", 10), "0,10");
3353                         Assert.AreEqual (UInt32.MinValue, Convert.ToUInt32 ("0", 8), "0,8");
3354                         Assert.AreEqual (UInt32.MinValue, Convert.ToUInt32 ("0", 2), "0,2");
3355                 }
3356
3357                 [Test]
3358                 public void ToUInt64_MaxValue ()
3359                 {
3360                         Assert.AreEqual (UInt64.MaxValue, Convert.ToUInt64 ("ffffffffffffffff", 16), "ffffffffffffffff,16");
3361                         Assert.AreEqual (UInt64.MaxValue, Convert.ToUInt64 ("0XFFFFFFFFFFFFFFFF", 16), "0XFFFFFFFFFFFFFFFF,16");
3362                         Assert.AreEqual (UInt64.MaxValue, Convert.ToUInt64 ("18446744073709551615", 10), "18446744073709551615,10");
3363                         Assert.AreEqual (UInt64.MaxValue, Convert.ToUInt64 ("1777777777777777777777", 8), "1777777777777777777777,8");
3364                         Assert.AreEqual (UInt64.MaxValue, Convert.ToUInt64 ("1111111111111111111111111111111111111111111111111111111111111111", 2), "1111111111111111111111111111111111111111111111111111111111111111,2");
3365                 }
3366
3367                 [Test]
3368                 public void ToUInt64_MinValue ()
3369                 {
3370                         Assert.AreEqual (UInt64.MinValue, Convert.ToUInt64 ("0", 16), "0,16");
3371                         Assert.AreEqual (UInt64.MinValue, Convert.ToUInt64 ("0x0", 16), "0x0,16");
3372                         Assert.AreEqual (UInt64.MinValue, Convert.ToUInt64 ("0", 10), "0,10");
3373                         Assert.AreEqual (UInt64.MinValue, Convert.ToUInt64 ("0", 8), "0,8");
3374                         Assert.AreEqual (UInt64.MinValue, Convert.ToUInt64 ("0", 2), "0,2");
3375                 }
3376
3377                 // min/max signed
3378
3379                 [Test]
3380                 public void ToSByte_MaxValue ()
3381                 {
3382                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("7f", 16), "7F,16");
3383                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("0X7F", 16), "0X7F,16");
3384                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("127", 10), "127,10");
3385                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("177", 8), "177,8");
3386                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("1111111", 2), "1111111,2");
3387                 }
3388
3389                 [Test]
3390                 public void ToSByte_MinValue ()
3391                 {
3392                         Assert.AreEqual (SByte.MinValue, Convert.ToSByte ("80", 16), "80,16");
3393                         Assert.AreEqual (SByte.MinValue, Convert.ToSByte ("-128", 10), "-128,10");
3394                         Assert.AreEqual (SByte.MinValue, Convert.ToSByte ("200", 8), "200,8");
3395                         Assert.AreEqual (SByte.MinValue, Convert.ToSByte ("10000000", 2), "10000000,2");
3396                 }
3397
3398                 [Test]
3399                 public void ToInt16_MaxValue ()
3400                 {
3401                         Assert.AreEqual (Int16.MaxValue, Convert.ToInt16 ("7fff", 16), "7FFF,16");
3402                         Assert.AreEqual (Int16.MaxValue, Convert.ToInt16 ("0X7FFF", 16), "0X7FFF,16");
3403                         Assert.AreEqual (Int16.MaxValue, Convert.ToInt16 ("32767", 10), "32767,10");
3404                         Assert.AreEqual (Int16.MaxValue, Convert.ToInt16 ("77777", 8), "77777,8");
3405                         Assert.AreEqual (Int16.MaxValue, Convert.ToInt16 ("111111111111111", 2), "111111111111111,2");
3406                 }
3407
3408                 [Test]
3409                 public void ToInt16_MinValue ()
3410                 {
3411                         Assert.AreEqual (Int16.MinValue, Convert.ToInt16 ("8000", 16), "8000,16");
3412                         Assert.AreEqual (Int16.MinValue, Convert.ToInt16 ("-32768", 10), "-32768,10");
3413                         Assert.AreEqual (Int16.MinValue, Convert.ToInt16 ("100000", 8), "100000,8");
3414                         Assert.AreEqual (Int16.MinValue, Convert.ToInt16 ("1000000000000000", 2), "1000000000000000,2");
3415                 }
3416
3417                 [Test]
3418                 public void ToInt32_MaxValue ()
3419                 {
3420                         Assert.AreEqual (Int32.MaxValue, Convert.ToInt32 ("7fffffff", 16), "7fffffff,16");
3421                         Assert.AreEqual (Int32.MaxValue, Convert.ToInt32 ("0X7FFFFFFF", 16), "0X7FFFFFFF,16");
3422                         Assert.AreEqual (Int32.MaxValue, Convert.ToInt32 ("2147483647", 10), "2147483647,10");
3423                         Assert.AreEqual (Int32.MaxValue, Convert.ToInt32 ("17777777777", 8), "17777777777,8");
3424                         Assert.AreEqual (Int32.MaxValue, Convert.ToInt32 ("1111111111111111111111111111111", 2), "1111111111111111111111111111111,2");
3425                 }
3426
3427                 [Test]
3428                 public void ToInt32_MinValue ()
3429                 {
3430                         Assert.AreEqual (Int32.MinValue, Convert.ToInt32 ("80000000", 16), "80000000,16");
3431                         Assert.AreEqual (Int32.MinValue, Convert.ToInt32 ("-2147483648", 10), "-2147483648,10");
3432                         Assert.AreEqual (Int32.MinValue, Convert.ToInt32 ("20000000000", 8), "20000000000,8");
3433                         Assert.AreEqual (Int32.MinValue, Convert.ToInt32 ("10000000000000000000000000000000", 2), "10000000000000000000000000000000,2");
3434                 }
3435
3436                 [Test]
3437                 public void ToInt64_MaxValue ()
3438                 {
3439                         Assert.AreEqual (Int64.MaxValue, Convert.ToInt64 ("7fffffffffffffff", 16), "7fffffffffffffff,16");
3440                         Assert.AreEqual (Int64.MaxValue, Convert.ToInt64 ("0X7FFFFFFFFFFFFFFF", 16), "0X7FFFFFFFFFFFFFFF,16");
3441                         Assert.AreEqual (Int64.MaxValue, Convert.ToInt64 ("9223372036854775807", 10), "9223372036854775807,10");
3442                         Assert.AreEqual (Int64.MaxValue, Convert.ToInt64 ("777777777777777777777", 8), "777777777777777777777,8");
3443                         Assert.AreEqual (Int64.MaxValue, Convert.ToInt64 ("111111111111111111111111111111111111111111111111111111111111111", 2), "111111111111111111111111111111111111111111111111111111111111111,2");
3444                 }
3445
3446                 [Test]
3447                 public void ToInt64_MinValue ()
3448                 {
3449                         Assert.AreEqual (Int64.MinValue, Convert.ToInt64 ("8000000000000000", 16), "8000000000000000,16");
3450                         Assert.AreEqual (Int64.MinValue, Convert.ToInt64 ("0x8000000000000000", 16), "0x8000000000000000,16");
3451                         Assert.AreEqual (Int64.MinValue, Convert.ToInt64 ("-9223372036854775808", 10), "-9223372036854775808,10");
3452                         Assert.AreEqual (Int64.MinValue, Convert.ToInt64 ("1000000000000000000000", 8), "1000000000000000000000,8");
3453                         Assert.AreEqual (Int64.MinValue, Convert.ToInt64 ("1000000000000000000000000000000000000000000000000000000000000000", 2), "1000000000000000000000000000000000000000000000000000000000000000,2");
3454                 }
3455
3456                 // signed types
3457
3458                 [Test]
3459                 [ExpectedException (typeof (OverflowException))]
3460                 public void ToSByte_OverMaxValue ()
3461                 {
3462                         string max_plus1 = "128";
3463                         Convert.ToSByte (max_plus1);
3464                 }
3465
3466                 [Test]
3467                 [ExpectedException (typeof (OverflowException))]
3468                 public void ToSByte_OverMinValue ()
3469                 {
3470                         string min_minus1 = "-129";
3471                         Convert.ToSByte (min_minus1);
3472                 }
3473
3474                 [Test]
3475                 [ExpectedException (typeof (OverflowException))]
3476                 public void ToInt16_OverMaxValue ()
3477                 {
3478                         string max_plus1 = "32768";
3479                         Convert.ToInt16 (max_plus1);
3480                 }
3481
3482                 [Test]
3483                 [ExpectedException (typeof (OverflowException))]
3484                 public void ToInt16_OverMinValue ()
3485                 {
3486                         string min_minus1 = "-32769";
3487                         Convert.ToInt16 (min_minus1);
3488                 }
3489
3490                 [Test]
3491                 [ExpectedException (typeof (OverflowException))]
3492                 public void ToInt32_OverMaxValue ()
3493                 {
3494                         string max_plus1 = "2147483648";
3495                         Convert.ToInt32 (max_plus1);
3496                 }
3497
3498                 [Test]
3499                 [ExpectedException (typeof (OverflowException))]
3500                 public void ToInt32_OverMinValue ()
3501                 {
3502                         string min_minus1 = "-2147483649";
3503                         Convert.ToInt32 (min_minus1);
3504                 }
3505
3506                 [Test]
3507                 [ExpectedException (typeof (OverflowException))]
3508                 public void ToInt64_OverMaxValue ()
3509                 {
3510                         string max_plus1 = "9223372036854775808";
3511                         Convert.ToInt64 (max_plus1);
3512                 }
3513
3514                 [Test]
3515                 [ExpectedException (typeof (OverflowException))]
3516                 public void ToInt64_OverMinValue ()
3517                 {
3518                         string min_minus1 = "-9223372036854775809";
3519                         Convert.ToInt64 (min_minus1);
3520                 }
3521
3522                 // unsigned types
3523
3524                 [Test]
3525                 [ExpectedException (typeof (OverflowException))]
3526                 public void ToByte_OverMaxValue ()
3527                 {
3528                         string max_plus1 = "257";
3529                         Convert.ToByte (max_plus1);
3530                 }
3531
3532                 [Test]
3533                 [ExpectedException (typeof (OverflowException))]
3534                 public void ToByte_OverMinValue ()
3535                 {
3536                         string min_minus1 = "-1";
3537                         Convert.ToByte (min_minus1);
3538                 }
3539
3540                 [Test]
3541                 [ExpectedException (typeof (OverflowException))]
3542                 public void ToUInt16_OverMaxValue ()
3543                 {
3544                         string max_plus1 = "65536";
3545                         Convert.ToUInt16 (max_plus1);
3546                 }
3547
3548                 [Test]
3549                 [ExpectedException (typeof (OverflowException))]
3550                 public void ToUInt16_OverMinValue ()
3551                 {
3552                         string min_minus1 = "-1";
3553                         Convert.ToUInt16 (min_minus1);
3554                 }
3555
3556                 [Test]
3557                 [ExpectedException (typeof (OverflowException))]
3558                 public void ToUInt32_OverMaxValue ()
3559                 {
3560                         string max_plus1 = "4294967296";
3561                         Convert.ToUInt32 (max_plus1);
3562                 }
3563
3564                 [Test]
3565                 [ExpectedException (typeof (OverflowException))]
3566                 public void ToUInt32_OverMinValue ()
3567                 {
3568                         string min_minus1 = "-1";
3569                         Convert.ToUInt32 (min_minus1);
3570                 }
3571
3572                 [Test]
3573                 [ExpectedException (typeof (OverflowException))]
3574                 public void ToUInt64_OverMaxValue ()
3575                 {
3576                         string max_plus1 = "18446744073709551616";
3577                         Convert.ToUInt64 (max_plus1);
3578                 }
3579
3580                 [Test]
3581                 [ExpectedException (typeof (OverflowException))]
3582                 public void ToUInt64_OverMinValue ()
3583                 {
3584                         string min_minus1 = "-1";
3585                         Convert.ToUInt64 (min_minus1);
3586                 }
3587
3588                 [Test]
3589                 public void To_NullString ()
3590                 {
3591                         string s = null;
3592                         // signed
3593                         Assert.AreEqual (0, Convert.ToSByte (s), "ToSByte");
3594                         Assert.AreEqual (0, Convert.ToSByte (s, 10), "ToSByte+base");
3595                         Assert.AreEqual (0, Convert.ToInt16 (s), "ToInt16");
3596                         Assert.AreEqual (0, Convert.ToInt16 (s, 10), "ToInt16+base");
3597                         Assert.AreEqual (0, Convert.ToInt32 (s), "ToInt32");
3598                         Assert.AreEqual (0, Convert.ToInt32 (s, 10), "ToInt32+base");
3599                         Assert.AreEqual (0, Convert.ToInt64 (s), "ToInt64");
3600                         Assert.AreEqual (0, Convert.ToInt64 (s, 10), "ToInt64+base");
3601                         // unsigned
3602                         Assert.AreEqual (0, Convert.ToByte (s), "ToByte");
3603                         Assert.AreEqual (0, Convert.ToByte (s, 10), "ToByte+base");
3604                         Assert.AreEqual (0, Convert.ToUInt16 (s), "ToUInt16");
3605                         Assert.AreEqual (0, Convert.ToUInt16 (s, 10), "ToUInt16+base");
3606                         Assert.AreEqual (0, Convert.ToUInt32 (s), "ToUInt32");
3607                         Assert.AreEqual (0, Convert.ToUInt32 (s, 10), "ToUInt32+base");
3608                         Assert.AreEqual (0, Convert.ToUInt64 (s), "ToUInt64");
3609                         Assert.AreEqual (0, Convert.ToUInt64 (s, 10), "ToUInt64+base");
3610                 }
3611
3612                 [Test]
3613                 public void To_NullObject ()
3614                 {
3615                         object o = null;
3616                         // signed
3617                         Assert.AreEqual (0, Convert.ToSByte (o), "ToSByte");
3618                         Assert.AreEqual (0, Convert.ToInt16 (o), "ToInt16");
3619                         Assert.AreEqual (0, Convert.ToInt32 (o), "ToInt32");
3620                         Assert.AreEqual (0, Convert.ToInt64 (o), "ToInt64");
3621                         // unsigned
3622                         Assert.AreEqual (0, Convert.ToByte (o), "ToByte");
3623                         Assert.AreEqual (0, Convert.ToUInt16 (o), "ToUInt16");
3624                         Assert.AreEqual (0, Convert.ToUInt32 (o), "ToUInt32");
3625                         Assert.AreEqual (0, Convert.ToUInt64 (o), "ToUInt64");
3626                 }
3627
3628                 [Test]
3629                 public void To_NullObjectFormatProvider ()
3630                 {
3631                         object o = null;
3632                         IFormatProvider fp = (IFormatProvider) new NumberFormatInfo ();
3633                         // signed
3634                         Assert.AreEqual (0, Convert.ToSByte (o, fp), "ToSByte");
3635                         Assert.AreEqual (0, Convert.ToInt16 (o, fp), "ToInt16");
3636                         Assert.AreEqual (0, Convert.ToInt32 (o, fp), "ToInt32");
3637                         Assert.AreEqual (0, Convert.ToInt64 (o, fp), "ToInt64");
3638                         // unsigned
3639                         Assert.AreEqual (0, Convert.ToByte (o, fp), "ToByte");
3640                         Assert.AreEqual (0, Convert.ToUInt16 (o, fp), "ToUInt16");
3641                         Assert.AreEqual (0, Convert.ToUInt32 (o, fp), "ToUInt32");
3642                         Assert.AreEqual (0, Convert.ToUInt64 (o, fp), "ToUInt64");
3643                 }
3644
3645                 [Test]
3646                 [ExpectedException (typeof (ArgumentNullException))]
3647                 public void ToSByte_NullStringFormatProvider ()
3648                 {
3649                         string s = null;
3650                         // SByte is a "special" case ???
3651                         Convert.ToSByte (s, new NumberFormatInfo ());
3652                 }
3653
3654                 [Test]
3655                 public void To_NullStringFormatProvider ()
3656                 {
3657                         string s = null;
3658                         IFormatProvider fp = (IFormatProvider) new NumberFormatInfo ();
3659                         // signed
3660                         // No SByte here
3661                         Assert.AreEqual (0, Convert.ToInt16 (s, fp), "ToInt16");
3662                         Assert.AreEqual (0, Convert.ToInt32 (s, fp), "ToInt32");
3663                         Assert.AreEqual (0, Convert.ToInt64 (s, fp), "ToInt64");
3664                         // unsigned
3665                         Assert.AreEqual (0, Convert.ToByte (s, fp), "ToByte");
3666                         Assert.AreEqual (0, Convert.ToUInt16 (s, fp), "ToUInt16");
3667                         Assert.AreEqual (0, Convert.ToUInt32 (s, fp), "ToUInt32");
3668                         Assert.AreEqual (0, Convert.ToUInt64 (s, fp), "ToUInt64");
3669                 }
3670
3671                 [Test]
3672                 [ExpectedException (typeof (InvalidCastException))]
3673                 public void ChangeTypeToTypeCodeEmpty ()
3674                 {
3675                         Convert.ChangeType (true, TypeCode.Empty);
3676                 }
3677
3678                 [Test]
3679                 [ExpectedException (typeof (ArgumentNullException))]
3680                 public void CharChangeTypeNullNull ()
3681                 {
3682                         char a = 'a';
3683                         IConvertible convert = a;
3684                         convert.ToType (null, null);
3685                 }
3686
3687                 [Test]
3688                 [ExpectedException (typeof (ArgumentNullException))]
3689                 public void StringChangeTypeNullNull ()
3690                 {
3691                         string a = "a";
3692                         IConvertible convert = a;
3693                         convert.ToType (null, null);
3694                 }
3695
3696                 [Test]
3697                 // 2005/01/10: The docs say this should throw an InvalidCastException,
3698                 // however, MS.NET 1.1 throws a NullReferenceException. Assuming docs
3699                 // are wrong.
3700 #if NET_2_0
3701                 [ExpectedException (typeof (InvalidCastException))]
3702 #else
3703                 [ExpectedException (typeof (NullReferenceException))]
3704 #endif
3705                 public void ChangeTypeNullToValuetype ()
3706                 {
3707                         Convert.ChangeType (null, typeof (int));
3708                 }
3709
3710                 [Test]
3711                 public void ToString_MinMax_WithBase ()
3712                 {
3713                         Assert.AreEqual ("0", Convert.ToString (Byte.MinValue, 2), "Byte.MinValue base 2");
3714                         Assert.AreEqual ("0", Convert.ToString (Byte.MinValue, 8), "Byte.MinValue base 8");
3715                         Assert.AreEqual ("0", Convert.ToString (Byte.MinValue, 10), "Byte.MinValue base 10");
3716                         Assert.AreEqual ("0", Convert.ToString (Byte.MinValue, 16), "Byte.MinValue base 16");
3717
3718                         Assert.AreEqual ("11111111", Convert.ToString (Byte.MaxValue, 2), "Byte.MaxValue base 2");
3719                         Assert.AreEqual ("377", Convert.ToString (Byte.MaxValue, 8), "Byte.MaxValue base 8");
3720                         Assert.AreEqual ("255", Convert.ToString (Byte.MaxValue, 10), "Byte.MaxValue base 10");
3721                         Assert.AreEqual ("ff", Convert.ToString (Byte.MaxValue, 16), "Byte.MaxValue base 16");
3722
3723                         Assert.AreEqual ("1000000000000000", Convert.ToString (Int16.MinValue, 2), "Int16.MinValue base 2");
3724                         Assert.AreEqual ("100000", Convert.ToString (Int16.MinValue, 8), "Int16.MinValue base 8");
3725                         Assert.AreEqual ("-32768", Convert.ToString (Int16.MinValue, 10), "Int16.MinValue base 10");
3726                         Assert.AreEqual ("8000", Convert.ToString (Int16.MinValue, 16), "Int16.MinValue base 16");
3727
3728                         Assert.AreEqual ("111111111111111", Convert.ToString (Int16.MaxValue, 2), "Int16.MaxValue base 2");
3729                         Assert.AreEqual ("77777", Convert.ToString (Int16.MaxValue, 8), "Int16.MaxValue base 8");
3730                         Assert.AreEqual ("32767", Convert.ToString (Int16.MaxValue, 10), "Int16.MaxValue base 10");
3731                         Assert.AreEqual ("7fff", Convert.ToString (Int16.MaxValue, 16), "Int16.MaxValue base 16");
3732
3733                         Assert.AreEqual ("10000000000000000000000000000000", Convert.ToString (Int32.MinValue, 2), "Int32.MinValue base 2");
3734                         Assert.AreEqual ("20000000000", Convert.ToString (Int32.MinValue, 8), "Int32.MinValue base 8");
3735                         Assert.AreEqual ("-2147483648", Convert.ToString (Int32.MinValue, 10), "Int32.MinValue base 10");
3736                         Assert.AreEqual ("80000000", Convert.ToString (Int32.MinValue, 16), "Int32.MinValue base 16");
3737
3738                         Assert.AreEqual ("1111111111111111111111111111111", Convert.ToString (Int32.MaxValue, 2), "Int32.MaxValue base 2");
3739                         Assert.AreEqual ("17777777777", Convert.ToString (Int32.MaxValue, 8), "Int32.MaxValue base 8");
3740                         Assert.AreEqual ("2147483647", Convert.ToString (Int32.MaxValue, 10), "Int32.MaxValue base 10");
3741                         Assert.AreEqual ("7fffffff", Convert.ToString (Int32.MaxValue, 16), "Int32.MaxValue base 16");
3742
3743                         Assert.AreEqual ("1000000000000000000000000000000000000000000000000000000000000000", Convert.ToString (Int64.MinValue, 2), "Int64.MinValue base 2");
3744                         Assert.AreEqual ("1000000000000000000000", Convert.ToString (Int64.MinValue, 8), "Int64.MinValue base 8");
3745                         Assert.AreEqual ("-9223372036854775808", Convert.ToString (Int64.MinValue, 10), "Int64.MinValue base 10");
3746                         Assert.AreEqual ("8000000000000000", Convert.ToString (Int64.MinValue, 16), "Int64.MinValue base 16");
3747
3748                         Assert.AreEqual ("111111111111111111111111111111111111111111111111111111111111111", Convert.ToString (Int64.MaxValue, 2), "Int64.MaxValue base 2");
3749                         Assert.AreEqual ("777777777777777777777", Convert.ToString (Int64.MaxValue, 8), "Int64.MaxValue base 8");
3750                         Assert.AreEqual ("9223372036854775807", Convert.ToString (Int64.MaxValue, 10), "Int64.MaxValue base 10");
3751                         Assert.AreEqual ("7fffffffffffffff", Convert.ToString (Int64.MaxValue, 16), "Int64.MaxValue base 16");
3752                 }
3753
3754                 [Test]
3755                 [ExpectedException (typeof (FormatException))]
3756                 public void ToByte_BadHexPrefix1 ()
3757                 {
3758                         Convert.ToByte ("#10", 16);
3759                 }
3760
3761                 [Test]
3762                 [ExpectedException (typeof (FormatException))]
3763                 public void ToByte_BadHexPrefix2 ()
3764                 {
3765                         Convert.ToByte ("&H10", 16);
3766                 }
3767
3768                 [Test]
3769                 [ExpectedException (typeof (FormatException))]
3770                 public void ToByte_BadHexPrefix3 ()
3771                 {
3772                         Convert.ToByte ("&h10", 16);
3773                 }
3774
3775                 [Test]
3776                 [ExpectedException (typeof (FormatException))]
3777                 public void ToInt16_BadHexPrefix1 ()
3778                 {
3779                         Convert.ToInt16 ("#10", 16);
3780                 }
3781
3782                 [Test]
3783                 [ExpectedException (typeof (FormatException))]
3784                 public void ToInt16_BadHexPrefix2 ()
3785                 {
3786                         Convert.ToInt16 ("&H10", 16);
3787                 }
3788
3789                 [Test]
3790                 [ExpectedException (typeof (FormatException))]
3791                 public void ToInt16_BadHexPrefix3 ()
3792                 {
3793                         Convert.ToInt16 ("&h10", 16);
3794                 }
3795
3796                 [Test]
3797                 [ExpectedException (typeof (FormatException))]
3798                 public void ToInt32_BadHexPrefix1 ()
3799                 {
3800                         Convert.ToInt32 ("#10", 16);
3801                 }
3802
3803                 [Test]
3804                 [ExpectedException (typeof (FormatException))]
3805                 public void ToInt32_BadHexPrefix2 ()
3806                 {
3807                         Convert.ToInt32 ("&H10", 16);
3808                 }
3809
3810                 [Test]
3811                 [ExpectedException (typeof (FormatException))]
3812                 public void ToInt32_BadHexPrefix3 ()
3813                 {
3814                         Convert.ToInt32 ("&h10", 16);
3815                 }
3816
3817                 [Test]
3818                 [ExpectedException (typeof (FormatException))]
3819                 public void ToInt64_BadHexPrefix1 ()
3820                 {
3821                         Convert.ToInt64 ("#10", 16);
3822                 }
3823
3824                 [Test]
3825                 [ExpectedException (typeof (FormatException))]
3826                 public void ToInt64_BadHexPrefix2 ()
3827                 {
3828                         Convert.ToInt64 ("&H10", 16);
3829                 }
3830
3831                 [Test]
3832                 [ExpectedException (typeof (FormatException))]
3833                 public void ToInt64_BadHexPrefix3 ()
3834                 {
3835                         Convert.ToInt64 ("&h10", 16);
3836                 }
3837
3838                 [Test]
3839                 [ExpectedException (typeof (FormatException))]
3840                 public void ToSByte_BadHexPrefix1 ()
3841                 {
3842                         Convert.ToSByte ("#10", 16);
3843                 }
3844
3845                 [Test]
3846                 [ExpectedException (typeof (FormatException))]
3847                 public void ToSByte_BadHexPrefix2 ()
3848                 {
3849                         Convert.ToSByte ("&H10", 16);
3850                 }
3851
3852                 [Test]
3853                 [ExpectedException (typeof (FormatException))]
3854                 public void ToSByte_BadHexPrefix3 ()
3855                 {
3856                         Convert.ToSByte ("&h10", 16);
3857                 }
3858
3859                 [Test]
3860                 [ExpectedException (typeof (FormatException))]
3861                 public void ToUInt16_BadHexPrefix1 ()
3862                 {
3863                         Convert.ToUInt16 ("#10", 16);
3864                 }
3865
3866                 [Test]
3867                 [ExpectedException (typeof (FormatException))]
3868                 public void ToUInt16_BadHexPrefix2 ()
3869                 {
3870                         Convert.ToUInt16 ("&H10", 16);
3871                 }
3872
3873                 [Test]
3874                 [ExpectedException (typeof (FormatException))]
3875                 public void ToUInt16_BadHexPrefix3 ()
3876                 {
3877                         Convert.ToUInt16 ("&h10", 16);
3878                 }
3879
3880                 [Test]
3881                 [ExpectedException (typeof (FormatException))]
3882                 public void ToUInt32_BadHexPrefix1 ()
3883                 {
3884                         Convert.ToUInt32 ("#10", 16);
3885                 }
3886
3887                 [Test]
3888                 [ExpectedException (typeof (FormatException))]
3889                 public void ToUInt32_BadHexPrefix2 ()
3890                 {
3891                         Convert.ToUInt32 ("&H10", 16);
3892                 }
3893
3894                 [Test]
3895                 [ExpectedException (typeof (FormatException))]
3896                 public void ToUInt32_BadHexPrefix3 ()
3897                 {
3898                         Convert.ToUInt32 ("&h10", 16);
3899                 }
3900
3901                 [Test]
3902                 [ExpectedException (typeof (FormatException))]
3903                 public void ToUInt64_BadHexPrefix1 ()
3904                 {
3905                         Convert.ToUInt64 ("#10", 16);
3906                 }
3907
3908                 [Test]
3909                 [ExpectedException (typeof (FormatException))]
3910                 public void ToUInt64_BadHexPrefix2 ()
3911                 {
3912                         Convert.ToUInt64 ("&H10", 16);
3913                 }
3914
3915                 [Test]
3916                 [ExpectedException (typeof (FormatException))]
3917                 public void ToUInt64_BadHexPrefix3 ()
3918                 {
3919                         Convert.ToUInt64 ("&h10", 16);
3920                 }
3921
3922                 [Test]
3923                 public void ToSByte_Base16_MinMax ()
3924                 {
3925                         Assert.AreEqual (SByte.MinValue, Convert.ToSByte ("80", 16), "80,16");
3926                         Assert.AreEqual (SByte.MinValue, Convert.ToSByte ("0x80", 16), "0x80,16");
3927                         Assert.AreEqual (SByte.MinValue, Convert.ToSByte ("0X80", 16), "0X80,16");
3928
3929                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("7f", 16), "7f,16");
3930                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("7F", 16), "7F,16");
3931                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("0x7f", 16), "0x7f,16");
3932                         Assert.AreEqual (SByte.MaxValue, Convert.ToSByte ("0X7F", 16), "0X7F,16");
3933                 }
3934
3935                 [Test]
3936                 public void ToInt16_Base16_MinMax ()
3937                 {
3938                         Assert.AreEqual (short.MinValue, Convert.ToInt16 ("8000", 16), "8000,16");
3939                         Assert.AreEqual (short.MinValue, Convert.ToInt16 ("0x8000", 16), "0x8000,16");
3940                         Assert.AreEqual (short.MinValue, Convert.ToInt16 ("0X8000", 16), "0X8000,16");
3941
3942                         Assert.AreEqual (short.MaxValue, Convert.ToInt16 ("7fff", 16), "7fff,16");
3943                         Assert.AreEqual (short.MaxValue, Convert.ToInt16 ("7FFF", 16), "7FFF,16");
3944                         Assert.AreEqual (short.MaxValue, Convert.ToInt16 ("0x7fff", 16), "0x7fff,16");
3945                         Assert.AreEqual (short.MaxValue, Convert.ToInt16 ("0X7FFF", 16), "0X7FFF,16");
3946                 }
3947
3948                 [Test]
3949                 public void ToInt32_Base16_MinMax ()
3950                 {
3951                         Assert.AreEqual (int.MinValue, Convert.ToInt32 ("80000000", 16), "80000000,16");
3952                         Assert.AreEqual (int.MinValue, Convert.ToInt32 ("0x80000000", 16), "0x80000000,16");
3953                         Assert.AreEqual (int.MinValue, Convert.ToInt32 ("0X80000000", 16), "0X80000000,16");
3954
3955                         Assert.AreEqual (int.MaxValue, Convert.ToInt32 ("7fffffff", 16), "7fffffff,16");
3956                         Assert.AreEqual (int.MaxValue, Convert.ToInt32 ("7FFFFFFF", 16), "7FFFFFFF,16");
3957                         Assert.AreEqual (int.MaxValue, Convert.ToInt32 ("0x7fffffff", 16), "0x7fffffff,16");
3958                         Assert.AreEqual (int.MaxValue, Convert.ToInt32 ("0X7FFFFFFF", 16), "0X7FFFFFFF,16");
3959                 }
3960
3961                 [Test]
3962                 [ExpectedException (typeof (FormatException))]
3963                 public void ToByte_Base10_InvalidChars1 ()
3964                 {
3965                         Convert.ToByte ("0-1", 10);
3966                 }
3967
3968                 [Test]
3969                 [ExpectedException (typeof (FormatException))]
3970                 public void ToByte_Base10_InvalidChars2 ()
3971                 {
3972                         Convert.ToByte ("FF", 10);
3973                 }
3974
3975                 [Test]
3976                 [ExpectedException (typeof (FormatException))]
3977                 public void ToInt16_Base10_InvalidChars1 ()
3978                 {
3979                         Convert.ToInt16 ("0-1", 10);
3980                 }
3981
3982                 [Test]
3983                 [ExpectedException (typeof (FormatException))]
3984                 public void ToInt16_Base10_InvalidChars2 ()
3985                 {
3986                         Convert.ToInt16 ("FF", 10);
3987                 }
3988
3989                 [Test]
3990                 [ExpectedException (typeof (FormatException))]
3991                 public void ToInt32_Base10_InvalidChars1 ()
3992                 {
3993                         Convert.ToInt32 ("0-1", 10);
3994                 }
3995
3996                 [Test]
3997                 [ExpectedException (typeof (FormatException))]
3998                 public void ToInt32_Base10_InvalidChars2 ()
3999                 {
4000                         Convert.ToInt32 ("FF", 10);
4001                 }
4002
4003                 [Test]
4004                 [ExpectedException (typeof (FormatException))]
4005                 public void ToInt64_Base10_InvalidChars1 ()
4006                 {
4007                         Convert.ToInt64 ("0-1", 10);
4008                 }
4009
4010                 [Test]
4011                 [ExpectedException (typeof (FormatException))]
4012                 public void ToInt64_Base10_InvalidChars2 ()
4013                 {
4014                         Convert.ToInt64 ("FF", 10);
4015                 }
4016
4017                 [Test]
4018                 [ExpectedException (typeof (FormatException))]
4019                 public void ToSByte_Base10_InvalidChars1 ()
4020                 {
4021                         Convert.ToSByte ("0-1", 10);
4022                 }
4023
4024                 [Test]
4025                 [ExpectedException (typeof (FormatException))]
4026                 public void ToSByte_Base10_InvalidChars2 ()
4027                 {
4028                         Convert.ToSByte ("FF", 10);
4029                 }
4030
4031                 [Test]
4032                 [ExpectedException (typeof (FormatException))]
4033                 public void ToUInt16_Base10_InvalidChars1 ()
4034                 {
4035                         Convert.ToUInt16 ("0-1", 10);
4036                 }
4037
4038                 [Test]
4039                 [ExpectedException (typeof (FormatException))]
4040                 public void ToUInt16_Base10_InvalidChars2 ()
4041                 {
4042                         Convert.ToUInt16 ("FF", 10);
4043                 }
4044
4045                 [Test]
4046                 [ExpectedException (typeof (FormatException))]
4047                 public void ToUInt32_Base10_InvalidChars1 ()
4048                 {
4049                         Convert.ToUInt32 ("0-1", 10);
4050                 }
4051
4052                 [Test]
4053                 [ExpectedException (typeof (FormatException))]
4054                 public void ToUInt32_Base10_InvalidChars2 ()
4055                 {
4056                         Convert.ToUInt32 ("FF", 10);
4057                 }
4058
4059                 [Test]
4060                 [ExpectedException (typeof (FormatException))]
4061                 public void ToUInt64_Base10_InvalidChars1 ()
4062                 {
4063                         Convert.ToUInt64 ("0-1", 10);
4064                 }
4065
4066                 [Test]
4067                 [ExpectedException (typeof (FormatException))]
4068                 public void ToUInt64_Base10_InvalidChars2 ()
4069                 {
4070                         Convert.ToUInt64 ("FF", 10);
4071                 }
4072
4073                 [Test]
4074                 [ExpectedException (typeof (FormatException))]
4075                 public void ToByte_Base16_InvalidChars1 ()
4076                 {
4077                         Convert.ToByte ("0-1", 16);
4078                 }
4079
4080                 [Test]
4081                 [ExpectedException (typeof (FormatException))]
4082                 public void ToByte_Base16_InvalidChars2 ()
4083                 {
4084                         Convert.ToByte ("GG", 16);
4085                 }
4086
4087                 [Test]
4088                 [ExpectedException (typeof (FormatException))]
4089                 public void ToInt16_Base16_InvalidChars1 ()
4090                 {
4091                         Convert.ToInt16 ("0-1", 16);
4092                 }
4093
4094                 [Test]
4095                 [ExpectedException (typeof (FormatException))]
4096                 public void ToInt16_Base16_InvalidChars2 ()
4097                 {
4098                         Convert.ToInt16 ("GG", 16);
4099                 }
4100
4101                 [Test]
4102                 [ExpectedException (typeof (FormatException))]
4103                 public void ToInt32_Base16_InvalidChars1 ()
4104                 {
4105                         Convert.ToInt32 ("0-1", 16);
4106                 }
4107
4108                 [Test]
4109                 [ExpectedException (typeof (FormatException))]
4110                 public void ToInt32_Base16_InvalidChars2 ()
4111                 {
4112                         Convert.ToInt32 ("GG", 16);
4113                 }
4114
4115                 [Test]
4116                 [ExpectedException (typeof (FormatException))]
4117                 public void ToInt64_Base16_InvalidChars1 ()
4118                 {
4119                         Convert.ToInt64 ("0-1", 16);
4120                 }
4121
4122                 [Test]
4123                 [ExpectedException (typeof (FormatException))]
4124                 public void ToInt64_Base16_InvalidChars2 ()
4125                 {
4126                         Convert.ToInt64 ("GG", 16);
4127                 }
4128
4129                 [Test]
4130                 [ExpectedException (typeof (FormatException))]
4131                 public void ToSByte_Base16_InvalidChars1 ()
4132                 {
4133                         Convert.ToSByte ("0-1", 16);
4134                 }
4135
4136                 [Test]
4137                 [ExpectedException (typeof (FormatException))]
4138                 public void ToSByte_Base16_InvalidChars2 ()
4139                 {
4140                         Convert.ToSByte ("GG", 16);
4141                 }
4142
4143                 [Test]
4144                 [ExpectedException (typeof (FormatException))]
4145                 public void ToUInt16_Base16_InvalidChars1 ()
4146                 {
4147                         Convert.ToUInt16 ("0-1", 16);
4148                 }
4149
4150                 [Test]
4151                 [ExpectedException (typeof (FormatException))]
4152                 public void ToUInt16_Base16_InvalidChars2 ()
4153                 {
4154                         Convert.ToUInt16 ("GG", 16);
4155                 }
4156
4157                 [Test]
4158                 [ExpectedException (typeof (FormatException))]
4159                 public void ToUInt32_Base16_InvalidChars1 ()
4160                 {
4161                         Convert.ToUInt32 ("0-1", 16);
4162                 }
4163
4164                 [Test]
4165                 [ExpectedException (typeof (FormatException))]
4166                 public void ToUInt32_Base16_InvalidChars2 ()
4167                 {
4168                         Convert.ToUInt32 ("GG", 16);
4169                 }
4170
4171                 [Test]
4172                 [ExpectedException (typeof (FormatException))]
4173                 public void ToUInt64_Base16_InvalidChars1 ()
4174                 {
4175                         Convert.ToUInt64 ("0-1", 16);
4176                 }
4177
4178                 [Test]
4179                 [ExpectedException (typeof (FormatException))]
4180                 public void ToUInt64_Base16_InvalidChars2 ()
4181                 {
4182                         Convert.ToUInt64 ("GG", 16);
4183                 }
4184
4185                 [Test]
4186                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4187                 public void ToByte_Base2_Empty ()
4188                 {
4189                         Convert.ToByte ("", 2);
4190                 }
4191
4192                 [Test]
4193                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4194                 public void ToByte_Base8_Empty ()
4195                 {
4196                         Convert.ToByte ("", 8);
4197                 }
4198
4199                 [Test]
4200                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4201                 public void ToByte_Base10_Empty ()
4202                 {
4203                         Convert.ToByte ("", 10);
4204                 }
4205
4206                 [Test]
4207                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4208                 public void ToByte_Base16_Empty ()
4209                 {
4210                         Convert.ToByte ("", 16);
4211                 }
4212
4213                 [Test]
4214                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4215                 public void ToInt16_Base2_Empty ()
4216                 {
4217                         Convert.ToInt16 ("", 2);
4218                 }
4219
4220                 [Test]
4221                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4222                 public void ToInt16_Base8_Empty ()
4223                 {
4224                         Convert.ToInt16 ("", 8);
4225                 }
4226
4227                 [Test]
4228                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4229                 public void ToInt16_Base10_Empty ()
4230                 {
4231                         Convert.ToInt16 ("", 10);
4232                 }
4233
4234                 [Test]
4235                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4236                 public void ToInt16_Base16_Empty ()
4237                 {
4238                         Convert.ToInt16 ("", 16);
4239                 }
4240
4241                 [Test]
4242                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4243                 public void ToInt32_Base2_Empty ()
4244                 {
4245                         Convert.ToInt32 ("", 2);
4246                 }
4247
4248                 [Test]
4249                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4250                 public void ToInt32_Base8_Empty ()
4251                 {
4252                         Convert.ToInt32 ("", 8);
4253                 }
4254
4255                 [Test]
4256                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4257                 public void ToInt32_Base10_Empty ()
4258                 {
4259                         Convert.ToInt32 ("", 10);
4260                 }
4261
4262                 [Test]
4263                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4264                 public void ToInt32_Base16_Empty ()
4265                 {
4266                         Convert.ToInt32 ("", 16);
4267                 }
4268
4269                 [Test]
4270                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4271                 public void ToInt64_Base2_Empty ()
4272                 {
4273                         Convert.ToInt64 ("", 2);
4274                 }
4275
4276                 [Test]
4277                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4278                 public void ToInt64_Base8_Empty ()
4279                 {
4280                         Convert.ToInt64 ("", 8);
4281                 }
4282
4283                 [Test]
4284                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4285                 public void ToInt64_Base10_Empty ()
4286                 {
4287                         Convert.ToInt64 ("", 10);
4288                 }
4289
4290                 [Test]
4291                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4292                 public void ToInt64_Base16_Empty ()
4293                 {
4294                         Convert.ToInt64 ("", 16);
4295                 }
4296
4297                 [Test]
4298                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4299                 public void ToSByte_Base2_Empty ()
4300                 {
4301                         Convert.ToSByte ("", 2);
4302                 }
4303
4304                 [Test]
4305                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4306                 public void ToSByte_Base8_Empty ()
4307                 {
4308                         Convert.ToSByte ("", 8);
4309                 }
4310
4311                 [Test]
4312                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4313                 public void ToSByte_Base10_Empty ()
4314                 {
4315                         Convert.ToSByte ("", 10);
4316                 }
4317
4318                 [Test]
4319                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4320                 public void ToSByte_Base16_Empty ()
4321                 {
4322                         Convert.ToSByte ("", 16);
4323                 }
4324
4325                 [Test]
4326                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4327                 public void ToUInt16_Base2_Empty ()
4328                 {
4329                         Convert.ToUInt16 ("", 2);
4330                 }
4331
4332                 [Test]
4333                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4334                 public void ToUInt16_Base8_Empty ()
4335                 {
4336                         Convert.ToUInt16 ("", 8);
4337                 }
4338
4339                 [Test]
4340                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4341                 public void ToUInt16_Base10_Empty ()
4342                 {
4343                         Convert.ToUInt16 ("", 10);
4344                 }
4345
4346                 [Test]
4347                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4348                 public void ToUInt16_Base16_Empty ()
4349                 {
4350                         Convert.ToUInt16 ("", 16);
4351                 }
4352
4353                 [Test]
4354                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4355                 public void ToUInt32_Base2_Empty ()
4356                 {
4357                         Convert.ToUInt32 ("", 2);
4358                 }
4359
4360                 [Test]
4361                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4362                 public void ToUInt32_Base8_Empty ()
4363                 {
4364                         Convert.ToUInt32 ("", 8);
4365                 }
4366
4367                 [Test]
4368                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4369                 public void ToUInt32_Base10_Empty ()
4370                 {
4371                         Convert.ToUInt32 ("", 10);
4372                 }
4373
4374                 [Test]
4375                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4376                 public void ToUInt32_Base16_Empty ()
4377                 {
4378                         Convert.ToUInt32 ("", 16);
4379                 }
4380
4381                 [Test]
4382                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4383                 public void ToUInt64_Base2_Empty ()
4384                 {
4385                         Convert.ToUInt64 ("", 2);
4386                 }
4387
4388                 [Test]
4389                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4390                 public void ToUInt64_Base8_Empty ()
4391                 {
4392                         Convert.ToUInt64 ("", 8);
4393                 }
4394
4395                 [Test]
4396                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4397                 public void ToUInt64_Base10_Empty ()
4398                 {
4399                         Convert.ToUInt64 ("", 10);
4400                 }
4401
4402                 [Test]
4403                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
4404                 public void ToUInt64_Base16_Empty ()
4405                 {
4406                         Convert.ToUInt64 ("", 16);
4407                 }
4408
4409                 [Test]
4410                 [ExpectedException (typeof (FormatException))]
4411                 public void ToByte_HexPrefixOnly ()
4412                 {
4413                         Convert.ToByte ("0x", 16);
4414                 }
4415
4416                 [Test]
4417                 [ExpectedException (typeof (FormatException))]
4418                 public void ToInt16_HexPrefixOnly ()
4419                 {
4420                         Convert.ToInt16 ("0x", 16);
4421                 }
4422
4423                 [Test]
4424                 [ExpectedException (typeof (FormatException))]
4425                 public void ToInt32_HexPrefixOnly ()
4426                 {
4427                         Convert.ToInt32 ("0x", 16);
4428                 }
4429
4430                 [Test]
4431                 [ExpectedException (typeof (FormatException))]
4432                 public void ToInt64_HexPrefixOnly ()
4433                 {
4434                         Convert.ToInt64 ("0x", 16);
4435                 }
4436
4437                 [Test]
4438                 [ExpectedException (typeof (FormatException))]
4439                 public void ToSByte_HexPrefixOnly ()
4440                 {
4441                         Convert.ToSByte ("0x", 16);
4442                 }
4443
4444                 [Test]
4445                 [ExpectedException (typeof (FormatException))]
4446                 public void ToUInt16_HexPrefixOnly ()
4447                 {
4448                         Convert.ToUInt16 ("0x", 16);
4449                 }
4450
4451                 [Test]
4452                 [ExpectedException (typeof (FormatException))]
4453                 public void ToUInt32_HexPrefixOnly ()
4454                 {
4455                         Convert.ToUInt32 ("0x", 16);
4456                 }
4457
4458                 [Test]
4459                 [ExpectedException (typeof (FormatException))]
4460                 public void ToUInt64_HexPrefixOnly ()
4461                 {
4462                         Convert.ToUInt64 ("0x", 16);
4463                 }
4464
4465                 [Test]
4466                 [ExpectedException (typeof (ArgumentException))]
4467                 public void ToByte_Base2_NegativeSignOnly ()
4468                 {
4469                         Convert.ToByte ("-", 2);
4470                 }
4471
4472                 [Test]
4473                 [ExpectedException (typeof (ArgumentException))]
4474                 public void ToByte_Base8_NegativeSignOnly ()
4475                 {
4476                         Convert.ToByte ("-", 8);
4477                 }
4478
4479                 [Test]
4480                 [ExpectedException (typeof (OverflowException))]
4481                 public void ToByte_Base10_NegativeSignOnly ()
4482                 {
4483                         Convert.ToByte ("-", 10);
4484                 }
4485
4486                 [Test]
4487                 [ExpectedException (typeof (ArgumentException))]
4488                 public void ToByte_Base16_NegativeSignOnly ()
4489                 {
4490                         Convert.ToByte ("-", 16);
4491                 }
4492
4493                 [Test]
4494                 [ExpectedException (typeof (ArgumentException))]
4495                 public void ToInt16_Base2_NegativeSignOnly ()
4496                 {
4497                         Convert.ToInt16 ("-", 2);
4498                 }
4499
4500                 [Test]
4501                 [ExpectedException (typeof (ArgumentException))]
4502                 public void ToInt16_Base8_NegativeSignOnly ()
4503                 {
4504                         Convert.ToInt16 ("-", 8);
4505                 }
4506
4507                 [Test]
4508                 [ExpectedException (typeof (FormatException))]
4509                 public void ToInt16_Base10_NegativeSignOnly ()
4510                 {
4511                         Convert.ToInt16 ("-", 10);
4512                 }
4513
4514                 [Test]
4515                 [ExpectedException (typeof (ArgumentException))]
4516                 public void ToInt16_Base16_NegativeSignOnly ()
4517                 {
4518                         Convert.ToInt16 ("-", 16);
4519                 }
4520
4521                 [Test]
4522                 [ExpectedException (typeof (ArgumentException))]
4523                 public void ToInt32_Base2_NegativeSignOnly ()
4524                 {
4525                         Convert.ToInt32 ("-", 2);
4526                 }
4527
4528                 [Test]
4529                 [ExpectedException (typeof (ArgumentException))]
4530                 public void ToInt32_Base8_NegativeSignOnly ()
4531                 {
4532                         Convert.ToInt32 ("-", 8);
4533                 }
4534
4535                 [Test]
4536                 [ExpectedException (typeof (FormatException))]
4537                 public void ToInt32_Base10_NegativeSignOnly ()
4538                 {
4539                         Convert.ToInt32 ("-", 10);
4540                 }
4541
4542                 [Test]
4543                 [ExpectedException (typeof (ArgumentException))]
4544                 public void ToInt32_Base16_NegativeSignOnly ()
4545                 {
4546                         Convert.ToInt32 ("-", 16);
4547                 }
4548
4549                 [Test]
4550                 [ExpectedException (typeof (ArgumentException))]
4551                 public void ToInt64_Base2_NegativeSignOnly ()
4552                 {
4553                         Convert.ToInt64 ("-", 2);
4554                 }
4555
4556                 [Test]
4557                 [ExpectedException (typeof (ArgumentException))]
4558                 public void ToInt64_Base8_NegativeSignOnly ()
4559                 {
4560                         Convert.ToInt64 ("-", 8);
4561                 }
4562
4563                 [Test]
4564                 [ExpectedException (typeof (FormatException))]
4565                 public void ToInt64_Base10_NegativeSignOnly ()
4566                 {
4567                         Convert.ToInt64 ("-", 10);
4568                 }
4569
4570                 [Test]
4571                 [ExpectedException (typeof (ArgumentException))]
4572                 public void ToInt64_Base16_NegativeSignOnly ()
4573                 {
4574                         Convert.ToInt64 ("-", 16);
4575                 }
4576
4577                 [Test]
4578                 [ExpectedException (typeof (ArgumentException))]
4579                 public void ToSByte_Base2_NegativeSignOnly ()
4580                 {
4581                         Convert.ToSByte ("-", 2);
4582                 }
4583
4584                 [Test]
4585                 [ExpectedException (typeof (ArgumentException))]
4586                 public void ToSByte_Base8_NegativeSignOnly ()
4587                 {
4588                         Convert.ToSByte ("-", 8);
4589                 }
4590
4591                 [Test]
4592                 [ExpectedException (typeof (FormatException))]
4593                 public void ToSByte_Base10_NegativeSignOnly ()
4594                 {
4595                         Convert.ToSByte ("-", 10);
4596                 }
4597
4598                 [Test]
4599                 [ExpectedException (typeof (ArgumentException))]
4600                 public void ToSByte_Base16_NegativeSignOnly ()
4601                 {
4602                         Convert.ToSByte ("-", 16);
4603                 }
4604
4605                 [Test]
4606                 [ExpectedException (typeof (ArgumentException))]
4607                 public void ToUInt16_Base2_NegativeSignOnly ()
4608                 {
4609                         Convert.ToUInt16 ("-", 2);
4610                 }
4611
4612                 [Test]
4613                 [ExpectedException (typeof (ArgumentException))]
4614                 public void ToUInt16_Base8_NegativeSignOnly ()
4615                 {
4616                         Convert.ToUInt16 ("-", 8);
4617                 }
4618
4619                 [Test]
4620                 [ExpectedException (typeof (OverflowException))]
4621                 public void ToUInt16_Base10_NegativeSignOnly ()
4622                 {
4623                         Convert.ToUInt16 ("-", 10);
4624                 }
4625
4626                 [Test]
4627                 [ExpectedException (typeof (ArgumentException))]
4628                 public void ToUInt16_Base16_NegativeSignOnly ()
4629                 {
4630                         Convert.ToUInt16 ("-", 16);
4631                 }
4632
4633                 [Test]
4634                 [ExpectedException (typeof (ArgumentException))]
4635                 public void ToUInt32_Base2_NegativeSignOnly ()
4636                 {
4637                         Convert.ToUInt32 ("-", 2);
4638                 }
4639
4640                 [Test]
4641                 [ExpectedException (typeof (ArgumentException))]
4642                 public void ToUInt32_Base8_NegativeSignOnly ()
4643                 {
4644                         Convert.ToUInt32 ("-", 8);
4645                 }
4646
4647                 [Test]
4648                 [ExpectedException (typeof (OverflowException))]
4649                 public void ToUInt32_Base10_NegativeSignOnly ()
4650                 {
4651                         Convert.ToUInt32 ("-", 10);
4652                 }
4653
4654                 [Test]
4655                 [ExpectedException (typeof (ArgumentException))]
4656                 public void ToUInt32_Base16_NegativeSignOnly ()
4657                 {
4658                         Convert.ToUInt32 ("-", 16);
4659                 }
4660
4661                 [Test]
4662                 [ExpectedException (typeof (ArgumentException))]
4663                 public void ToUInt64_Base2_NegativeSignOnly ()
4664                 {
4665                         Convert.ToUInt64 ("-", 2);
4666                 }
4667
4668                 [Test]
4669                 [ExpectedException (typeof (ArgumentException))]
4670                 public void ToUInt64_Base8_NegativeSignOnly ()
4671                 {
4672                         Convert.ToUInt64 ("-", 8);
4673                 }
4674
4675                 [Test]
4676                 [ExpectedException (typeof (OverflowException))]
4677                 public void ToUInt64_Base10_NegativeSignOnly ()
4678                 {
4679                         Convert.ToUInt64 ("-", 10);
4680                 }
4681
4682                 [Test]
4683                 [ExpectedException (typeof (ArgumentException))]
4684                 public void ToUInt64_Base16_NegativeSignOnly ()
4685                 {
4686                         Convert.ToUInt64 ("-", 16);
4687                 }
4688
4689                 [Test] // bug #481687
4690                 public void ChangeType_Value_IConvertible ()
4691                 {
4692                         BitmapStatus bitmapStatus = new BitmapStatus (3);
4693                         Image c1 = Convert.ChangeType (bitmapStatus, typeof (Image)) as Image;
4694                         Assert.IsNotNull (c1, "#A1");
4695                         Assert.AreEqual (32, c1.ColorDepth, "#A2");
4696
4697                         bitmapStatus.ConvertToImage = false;
4698                         object c2 = Convert.ChangeType (bitmapStatus, typeof (Image));
4699                         Assert.IsNull (c2, "#B");
4700
4701                         object c3 = Convert.ChangeType (bitmapStatus, typeof (int));
4702                         Assert.IsNotNull (c3, "#C1");
4703                         Assert.AreEqual (3, c3, "#C2");
4704                 }
4705
4706                 // This is a simple and happy struct.
4707                 struct Foo {
4708                 }
4709
4710                 [Test]
4711                 [ExpectedException (typeof (InvalidCastException))]
4712                 public void ChangeType_ShouldThrowOnString ()
4713                 {
4714                         Convert.ChangeType ("this-is-a-string", typeof (Foo));
4715                 }
4716
4717                 [Test]
4718                 [ExpectedException (typeof (OverflowException))]
4719                 public void ToInt32_NaN ()
4720                 {
4721                         Convert.ToInt32 (Double.NaN);
4722                 }
4723
4724                 [Test]
4725                 public void ChangeTypeFromInvalidDouble ()
4726                 {
4727                         // types which should generate OverflowException from double.NaN, etc.
4728                         Type[] types = new Type []{
4729                                 typeof (byte), typeof (sbyte), typeof (decimal),
4730                                 typeof (short), typeof (int), typeof (long),
4731                                 typeof (ushort), typeof (uint), typeof (ulong),
4732                         };
4733
4734                         CheckChangeTypeOverflow ("double.NaN",              double.NaN,               types);
4735                         CheckChangeTypeOverflow ("double.PositiveInfinity", double.PositiveInfinity,  types);
4736                         CheckChangeTypeOverflow ("double.NegativeInfinity", double.NegativeInfinity,  types);
4737                         CheckChangeTypeOverflow ("float.NaN",               float.NaN,                types);
4738                         CheckChangeTypeOverflow ("float.PositiveInfinity",  float.PositiveInfinity,   types);
4739                         CheckChangeTypeOverflow ("float.NegativeInfinity",  float.NegativeInfinity,   types);
4740                 }
4741
4742                 static void CheckChangeTypeOverflow (string svalue, object value, Type[] types)
4743                 {
4744                         foreach (Type type in types) {
4745                                 string message = string.Format (" when converting {0} to {1}", svalue, type.FullName);
4746                                 try {
4747                                         Convert.ChangeType (value, type);
4748                                         Assert.Fail ("Expected System.OverflowException " + message);
4749                                 }
4750                                 catch (OverflowException) {
4751                                         // success
4752                                 }
4753                                 catch (Exception e) {
4754                                         Assert.Fail ("Unexpected exception type " + e.GetType ().FullName + message);
4755                                 }
4756                         }
4757                 }
4758         }
4759
4760         public class Image
4761         {
4762                 private int colorDepth;
4763
4764                 public Image ()
4765                 {
4766                         colorDepth = 8;
4767                 }
4768
4769                 public Image (int colorDepth)
4770                 {
4771                         this.colorDepth = colorDepth;
4772                 }
4773
4774                 public int ColorDepth {
4775                         get { return colorDepth; }
4776                 }
4777         }
4778
4779         public class BitmapStatus : IConvertible
4780         {
4781                 protected int m_Status;
4782                 private bool convertToImage;
4783
4784                 public BitmapStatus (int status)
4785                 {
4786                         m_Status = status;
4787                         convertToImage = true;
4788                 }
4789
4790                 public bool ConvertToImage {
4791                         get { return convertToImage; }
4792                         set { convertToImage = value; }
4793                 }
4794
4795                 TypeCode IConvertible.GetTypeCode ()
4796                 {
4797                         return TypeCode.Int32;
4798                 }
4799
4800                 bool IConvertible.ToBoolean (IFormatProvider provider)
4801                 {
4802                         return (bool)((IConvertible)this).ToType (typeof (bool), provider);
4803                 }
4804
4805                 byte IConvertible.ToByte (IFormatProvider provider)
4806                 {
4807                         return (byte)((IConvertible)this).ToType (typeof (byte), provider);
4808                 }
4809
4810                 char IConvertible.ToChar (IFormatProvider provider)
4811                 {
4812                         return (char)((IConvertible)this).ToType (typeof (char), provider);
4813                 }
4814
4815                 DateTime IConvertible.ToDateTime (IFormatProvider provider)
4816                 {
4817                         return (DateTime)((IConvertible)this).ToType (typeof (DateTime), provider);
4818                 }
4819
4820                 decimal IConvertible.ToDecimal (IFormatProvider provider)
4821                 {
4822                         return (decimal)((IConvertible)this).ToType (typeof (decimal), provider);
4823                 }
4824
4825                 double IConvertible.ToDouble (IFormatProvider provider)
4826                 {
4827                         return (double)((IConvertible)this).ToType (typeof (double), provider);
4828                 }
4829
4830                 short IConvertible.ToInt16 (IFormatProvider provider)
4831                 {
4832                         return (short)((IConvertible)this).ToType (typeof (short), provider);
4833                 }
4834
4835                 int IConvertible.ToInt32 (IFormatProvider provider)
4836                 {
4837                         return (int)m_Status;
4838                 }
4839
4840                 long IConvertible.ToInt64 (IFormatProvider provider)
4841                 {
4842                         return (long)((IConvertible)this).ToType (typeof (long), provider);
4843                 }
4844
4845                 sbyte IConvertible.ToSByte (IFormatProvider provider)
4846                 {
4847                         return (sbyte)((IConvertible)this).ToType (typeof (sbyte), provider);
4848                 }
4849
4850                 float IConvertible.ToSingle (IFormatProvider provider)
4851                 {
4852                         return (float)((IConvertible)this).ToType (typeof (float), provider);
4853                 }
4854
4855                 string IConvertible.ToString (IFormatProvider provider)
4856                 {
4857                         return (string)((IConvertible)this).ToType (typeof (string), provider);
4858                 }
4859
4860                 object IConvertible.ToType (Type conversionType, IFormatProvider provider)
4861                 {
4862                         if (ConvertToImage && conversionType == typeof (Image))
4863                                 return new Image (32);
4864                         else if (conversionType.IsAssignableFrom (typeof (int)))
4865                                 return Convert.ChangeType (1, conversionType, provider);
4866                         return null;
4867                 }
4868
4869                 ushort IConvertible.ToUInt16 (IFormatProvider provider)
4870                 {
4871                         return (ushort)((IConvertible)this).ToType (typeof (ushort), provider);
4872                 }
4873
4874                 uint IConvertible.ToUInt32 (IFormatProvider provider)
4875                 {
4876                         return (uint)((IConvertible)this).ToType (typeof (uint), provider);
4877                 }
4878
4879                 ulong IConvertible.ToUInt64 (IFormatProvider provider)
4880                 {
4881                         return (ulong)((IConvertible)this).ToType (typeof (ulong), provider);
4882                 }
4883         }
4884 }