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

   1 //
   2 // BitConverterTest.cs - NUnit Test Cases for System.BitConverter
   3 //
   4 // author:
   5 //   Duco Fijma (duco@lorentz.xs4all.nl)
   6 //
   7 // (C) 2002 Duco Fijma
   8 // Copyright (C) 2004 Novell (http://www.novell.com)
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13
  14 namespace MonoTests.System
  15 {
  16         [TestFixture]
  17         public class BitConverterTest
  18         {
  19                 public void TestIsLittleEndian ()
  20                 {
  21                         byte [] b = BitConverter.GetBytes (1);
  22                         Assert.AreEqual (b [0] == 1, BitConverter.IsLittleEndian, "#1");
  23                 }
  24
  25                 private void PrivateTestSingle (float v1)
  26                 {
  27                         float v2;
  28                         byte [] b;
  29                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
  30
  31                         b = BitConverter.GetBytes (v1);
  32                         Assert.AreEqual (4, b.Length, "#A1");
  33
  34                         v2 = BitConverter.ToSingle (b, 0);
  35                         Assert.AreEqual (v1, v2, "#A2");
  36
  37                         b.CopyTo (larger, 1);
  38                         v2 = BitConverter.ToSingle (larger, 1);
  39                         Assert.AreEqual (v1, v2, "#A3");
  40
  41                         try {
  42                                 BitConverter.ToSingle (larger, 8);
  43                                 Assert.Fail ("#B1");
  44                         } catch (ArgumentException ex) {
  45                                 // Destination array is not long enough to copy all the items
  46                                 // in the collection. Check array index and length
  47                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
  48                                 Assert.IsNull (ex.InnerException, "#B3");
  49                                 Assert.IsNotNull (ex.Message, "#B4");
  50                                 Assert.IsNull (ex.ParamName, "#B5");
  51                         }
  52
  53                         try {
  54                                 BitConverter.ToSingle (larger, 10);
  55                                 Assert.Fail ("#C1");
  56                         } catch (ArgumentOutOfRangeException ex) {
  57                                 // Index was out of range. Must be non-negative and less than
  58                                 // the size of the collection
  59                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
  60                                 Assert.IsNull (ex.InnerException, "#C3");
  61                                 Assert.IsNotNull (ex.Message, "#C4");
  62                                 Assert.IsNotNull (ex.ParamName, "#C5");
  63                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
  64                         }
  65                 }
  66
  67                 [Test]
  68                 public void TestSingle ()
  69                 {
  70                         PrivateTestSingle (0.1f);
  71                         PrivateTestSingle (24.1e30f);
  72                 }
  73
  74                 [Test]
  75                 public void ToSingle_Value_Null ()
  76                 {
  77                         try {
  78                                 BitConverter.ToSingle ((byte []) null, 77);
  79                                 Assert.Fail ("#1");
  80                         } catch (ArgumentNullException ex) {
  81                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  82                                 Assert.IsNull (ex.InnerException, "#3");
  83                                 Assert.IsNotNull (ex.Message, "#4");
  84                                 Assert.IsNotNull (ex.ParamName, "#5");
  85                                 Assert.AreEqual ("value", ex.ParamName, "#6");
  86                         }
  87                 }
  88
  89                 private void PrivateTestDouble (double v1)
  90                 {
  91                         double v2;
  92                         byte [] b;
  93                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
  94
  95                         b = BitConverter.GetBytes (v1);
  96                         Assert.AreEqual (8, b.Length, "#A1");
  97
  98                         v2 = BitConverter.ToDouble (b, 0);
  99                         Assert.AreEqual (v1, v2, "#A2");
 100
 101                         b.CopyTo (larger, 1);
 102                         v2 = BitConverter.ToDouble (larger, 1);
 103                         Assert.AreEqual (v1, v2, "#A3");
 104
 105                         try {
 106                                 BitConverter.ToDouble (larger, 3);
 107                                 Assert.Fail ("#B1");
 108                         } catch (ArgumentException ex) {
 109                                 // Destination array is not long enough to copy all the items
 110                                 // in the collection. Check array index and length
 111                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 112                                 Assert.IsNull (ex.InnerException, "#B3");
 113                                 Assert.IsNotNull (ex.Message, "#B4");
 114                                 Assert.IsNull (ex.ParamName, "#B5");
 115                         }
 116
 117                         try {
 118                                 BitConverter.ToDouble (larger, 10);
 119                                 Assert.Fail ("#C1");
 120                         } catch (ArgumentOutOfRangeException ex) {
 121                                 // Index was out of range. Must be non-negative and less than
 122                                 // the size of the collection
 123                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 124                                 Assert.IsNull (ex.InnerException, "#C3");
 125                                 Assert.IsNotNull (ex.Message, "#C4");
 126                                 Assert.IsNotNull (ex.ParamName, "#C5");
 127                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 128                         }
 129                 }
 130
 131                 [Test]
 132                 public void TestDouble ()
 133                 {
 134                         double d = 123.321;
 135
 136                         Assert.AreEqual (d, BitConverter.Int64BitsToDouble (BitConverter.DoubleToInt64Bits (d)), "#1");
 137
 138                         PrivateTestDouble (0.1);
 139                         PrivateTestDouble (24.1e77);
 140                 }
 141
 142                 [Test]
 143                 public void ToDouble_Value_Null ()
 144                 {
 145                         try {
 146                                 BitConverter.ToDouble ((byte []) null, 77);
 147                                 Assert.Fail ("#1");
 148                         } catch (ArgumentNullException ex) {
 149                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 150                                 Assert.IsNull (ex.InnerException, "#3");
 151                                 Assert.IsNotNull (ex.Message, "#4");
 152                                 Assert.IsNotNull (ex.ParamName, "#5");
 153                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 154                         }
 155                 }
 156
 157                 private void PrivateTestBool (bool v1)
 158                 {
 159                         bool v2;
 160                         byte [] b;
 161                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03 };
 162
 163                         b = BitConverter.GetBytes (v1);
 164                         Assert.AreEqual (1, b.Length, "#A1");
 165
 166                         v2 = BitConverter.ToBoolean (b, 0);
 167                         Assert.AreEqual (v1, v2, "#A2");
 168
 169                         b.CopyTo (larger, 1);
 170                         v2 = BitConverter.ToBoolean (larger, 1);
 171                         Assert.AreEqual (v1, v2, "#A3");
 172
 173                         try {
 174                                 BitConverter.ToBoolean (larger, 4);
 175                                 Assert.Fail ("#B1");
 176                         } catch (ArgumentOutOfRangeException ex) {
 177                                 // Index was out of range. Must be non-negative and less than
 178                                 // the size of the collection
 179                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 180                                 Assert.IsNull (ex.InnerException, "#B3");
 181                                 Assert.IsNotNull (ex.Message, "#B4");
 182                                 Assert.IsNotNull (ex.ParamName, "#B5");
 183                                 Assert.AreEqual ("startIndex", ex.ParamName, "#B6");
 184                         }
 185                 }
 186
 187                 [Test]
 188                 public void TestBool ()
 189                 {
 190                         PrivateTestBool (true);
 191                         PrivateTestBool (false);
 192                 }
 193
 194                 [Test]
 195                 public void ToBoolean_Value_Null ()
 196                 {
 197                         try {
 198                                 BitConverter.ToBoolean ((byte []) null, 77);
 199                                 Assert.Fail ("#1");
 200                         } catch (ArgumentNullException ex) {
 201                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 202                                 Assert.IsNull (ex.InnerException, "#3");
 203                                 Assert.IsNotNull (ex.Message, "#4");
 204                                 Assert.IsNotNull (ex.ParamName, "#5");
 205                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 206                         }
 207                 }
 208
 209                 private void PrivateTestChar (char v1)
 210                 {
 211                         char v2;
 212                         byte [] b;
 213                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03 };
 214
 215                         b = BitConverter.GetBytes (v1);
 216                         Assert.AreEqual (2, b.Length, "#A1");
 217
 218                         v2 = BitConverter.ToChar (b, 0);
 219                         Assert.AreEqual (v1, v2, "#A2");
 220
 221                         b.CopyTo (larger, 1);
 222                         v2 = BitConverter.ToChar (larger, 1);
 223                         Assert.AreEqual (v1, v2, "#A3");
 224
 225                         try {
 226                                 BitConverter.ToChar (larger, 3);
 227                                 Assert.Fail ("#B1");
 228                         } catch (ArgumentException ex) {
 229                                 // Destination array is not long enough to copy all the items
 230                                 // in the collection. Check array index and length
 231                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 232                                 Assert.IsNull (ex.InnerException, "#B3");
 233                                 Assert.IsNotNull (ex.Message, "#B4");
 234                                 Assert.IsNull (ex.ParamName, "#B5");
 235                         }
 236
 237                         try {
 238                                 BitConverter.ToChar (larger, 4);
 239                                 Assert.Fail ("#C1");
 240                         } catch (ArgumentOutOfRangeException ex) {
 241                                 // Index was out of range. Must be non-negative and less than
 242                                 // the size of the collection
 243                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 244                                 Assert.IsNull (ex.InnerException, "#C3");
 245                                 Assert.IsNotNull (ex.Message, "#C4");
 246                                 Assert.IsNotNull (ex.ParamName, "#C5");
 247                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 248                         }
 249                 }
 250
 251                 [Test]
 252                 public void TestChar ()
 253                 {
 254                         PrivateTestChar ('A');
 255                         PrivateTestChar ('\x01ff');
 256                 }
 257
 258                 [Test]
 259                 public void ToChar_Value_Null ()
 260                 {
 261                         try {
 262                                 BitConverter.ToChar ((byte []) null, 77);
 263                                 Assert.Fail ("#1");
 264                         } catch (ArgumentNullException ex) {
 265                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 266                                 Assert.IsNull (ex.InnerException, "#3");
 267                                 Assert.IsNotNull (ex.Message, "#4");
 268                                 Assert.IsNotNull (ex.ParamName, "#5");
 269                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 270                         }
 271                 }
 272
 273                 private void PrivateTestInt16 (short v1)
 274                 {
 275                         short v2;
 276                         byte [] b;
 277                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03 };
 278
 279                         b = BitConverter.GetBytes (v1);
 280                         Assert.AreEqual (2, b.Length, "#A1");
 281
 282                         v2 = BitConverter.ToInt16 (b, 0);
 283                         Assert.AreEqual (v1, v2, "#A2");
 284
 285                         b.CopyTo (larger, 1);
 286                         v2 = BitConverter.ToInt16 (larger, 1);
 287                         Assert.AreEqual (v1, v2, "#A3");
 288
 289                         try {
 290                                 BitConverter.ToInt16 (larger, 3);
 291                                 Assert.Fail ("#B1");
 292                         } catch (ArgumentException ex) {
 293                                 // Destination array is not long enough to copy all the items
 294                                 // in the collection. Check array index and length
 295                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 296                                 Assert.IsNull (ex.InnerException, "#B3");
 297                                 Assert.IsNotNull (ex.Message, "#B4");
 298                                 Assert.IsNull (ex.ParamName, "#B5");
 299                         }
 300
 301                         try {
 302                                 BitConverter.ToInt16 (larger, 4);
 303                                 Assert.Fail ("#C1");
 304                         } catch (ArgumentOutOfRangeException ex) {
 305                                 // Index was out of range. Must be non-negative and less than
 306                                 // the size of the collection
 307                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 308                                 Assert.IsNull (ex.InnerException, "#C3");
 309                                 Assert.IsNotNull (ex.Message, "#C4");
 310                                 Assert.IsNotNull (ex.ParamName, "#C5");
 311                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 312                         }
 313                 }
 314
 315                 [Test]
 316                 public void TestInt16 ()
 317                 {
 318                         PrivateTestInt16 (0);
 319                         PrivateTestInt16 (1000);
 320                         PrivateTestInt16 (-32768);
 321                         PrivateTestInt16 (32767);
 322                 }
 323
 324                 [Test]
 325                 public void ToInt16_Value_Null ()
 326                 {
 327                         try {
 328                                 BitConverter.ToInt16 ((byte []) null, 77);
 329                                 Assert.Fail ("#1");
 330                         } catch (ArgumentNullException ex) {
 331                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 332                                 Assert.IsNull (ex.InnerException, "#3");
 333                                 Assert.IsNotNull (ex.Message, "#4");
 334                                 Assert.IsNotNull (ex.ParamName, "#5");
 335                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 336                         }
 337                 }
 338
 339                 private void PrivateTestUInt16 (ushort v1)
 340                 {
 341                         ushort v2;
 342                         byte [] b;
 343                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03 };
 344
 345                         b = BitConverter.GetBytes (v1);
 346                         Assert.AreEqual (2, b.Length, "#A1");
 347
 348                         v2 = BitConverter.ToUInt16 (b, 0);
 349                         Assert.AreEqual (v1, v2, "#A2");
 350
 351                         b.CopyTo (larger, 1);
 352                         v2 = BitConverter.ToUInt16 (larger, 1);
 353                         Assert.AreEqual (v1, v2, "#A3");
 354
 355                         try {
 356                                 BitConverter.ToUInt16 (larger, 3);
 357                                 Assert.Fail ("#B1");
 358                         } catch (ArgumentException ex) {
 359                                 // Destination array is not long enough to copy all the items
 360                                 // in the collection. Check array index and length
 361                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 362                                 Assert.IsNull (ex.InnerException, "#B3");
 363                                 Assert.IsNotNull (ex.Message, "#B4");
 364                                 Assert.IsNull (ex.ParamName, "#B5");
 365                         }
 366
 367                         try {
 368                                 BitConverter.ToUInt16 (larger, 4);
 369                                 Assert.Fail ("#C1");
 370                         } catch (ArgumentOutOfRangeException ex) {
 371                                 // Index was out of range. Must be non-negative and less than
 372                                 // the size of the collection
 373                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 374                                 Assert.IsNull (ex.InnerException, "#C3");
 375                                 Assert.IsNotNull (ex.Message, "#C4");
 376                                 Assert.IsNotNull (ex.ParamName, "#C5");
 377                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 378                         }
 379                 }
 380
 381                 [Test]
 382                 public void TestUInt16 ()
 383                 {
 384                         PrivateTestUInt16 (0);
 385                         PrivateTestUInt16 (1000);
 386                         PrivateTestUInt16 (65535);
 387                 }
 388
 389                 [Test]
 390                 public void ToUInt16_Value_Null ()
 391                 {
 392                         try {
 393                                 BitConverter.ToUInt16 ((byte []) null, 77);
 394                                 Assert.Fail ("#1");
 395                         } catch (ArgumentNullException ex) {
 396                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 397                                 Assert.IsNull (ex.InnerException, "#3");
 398                                 Assert.IsNotNull (ex.Message, "#4");
 399                                 Assert.IsNotNull (ex.ParamName, "#5");
 400                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 401                         }
 402                 }
 403
 404                 private void PrivateTestInt32 (int v1)
 405                 {
 406                         int v2;
 407                         byte [] b;
 408                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
 409
 410                         b = BitConverter.GetBytes (v1);
 411                         Assert.AreEqual (4, b.Length, "#A1");
 412
 413                         v2 = BitConverter.ToInt32 (b, 0);
 414                         Assert.AreEqual (v1, v2, "#A2");
 415
 416                         b.CopyTo (larger, 1);
 417                         v2 = BitConverter.ToInt32 (larger, 1);
 418                         Assert.AreEqual (v1, v2, "#A3");
 419
 420                         try {
 421                                 BitConverter.ToInt32 (larger, 8);
 422                                 Assert.Fail ("#B1");
 423                         } catch (ArgumentException ex) {
 424                                 // Destination array is not long enough to copy all the items
 425                                 // in the collection. Check array index and length
 426                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 427                                 Assert.IsNull (ex.InnerException, "#B3");
 428                                 Assert.IsNotNull (ex.Message, "#B4");
 429                                 Assert.IsNull (ex.ParamName, "#B5");
 430                         }
 431
 432                         try {
 433                                 BitConverter.ToInt32 (larger, 10);
 434                                 Assert.Fail ("#C1");
 435                         } catch (ArgumentOutOfRangeException ex) {
 436                                 // Index was out of range. Must be non-negative and less than
 437                                 // the size of the collection
 438                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 439                                 Assert.IsNull (ex.InnerException, "#C3");
 440                                 Assert.IsNotNull (ex.Message, "#C4");
 441                                 Assert.IsNotNull (ex.ParamName, "#C5");
 442                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 443                         }
 444                 }
 445
 446                 [Test]
 447                 public void TestInt32 ()
 448                 {
 449                         PrivateTestInt32 (0);
 450                         PrivateTestInt32 (1000);
 451                         PrivateTestInt32 (-2147483648);
 452                         PrivateTestInt32 (2147483647);
 453                 }
 454
 455                 [Test]
 456                 public void ToInt32_Value_Null ()
 457                 {
 458                         try {
 459                                 BitConverter.ToInt32 ((byte []) null, 77);
 460                                 Assert.Fail ("#1");
 461                         } catch (ArgumentNullException ex) {
 462                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 463                                 Assert.IsNull (ex.InnerException, "#3");
 464                                 Assert.IsNotNull (ex.Message, "#4");
 465                                 Assert.IsNotNull (ex.ParamName, "#5");
 466                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 467                         }
 468                 }
 469
 470                 private void PrivateTestUInt32 (uint v1)
 471                 {
 472                         uint v2;
 473                         byte [] b;
 474                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
 475
 476                         b = BitConverter.GetBytes (v1);
 477                         Assert.AreEqual (4, b.Length, "#A1");
 478
 479                         v2 = BitConverter.ToUInt32 (b, 0);
 480                         Assert.AreEqual (v1, v2, "#A2");
 481
 482                         b.CopyTo (larger, 1);
 483                         v2 = BitConverter.ToUInt32 (larger, 1);
 484                         Assert.AreEqual (v1, v2, "#A3");
 485
 486                         try {
 487                                 BitConverter.ToUInt32 (larger, 8);
 488                                 Assert.Fail ("#B1");
 489                         } catch (ArgumentException ex) {
 490                                 // Destination array is not long enough to copy all the items
 491                                 // in the collection. Check array index and length
 492                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 493                                 Assert.IsNull (ex.InnerException, "#B3");
 494                                 Assert.IsNotNull (ex.Message, "#B4");
 495                                 Assert.IsNull (ex.ParamName, "#B5");
 496                         }
 497
 498                         try {
 499                                 BitConverter.ToUInt32 (larger, 10);
 500                                 Assert.Fail ("#C1");
 501                         } catch (ArgumentOutOfRangeException ex) {
 502                                 // Index was out of range. Must be non-negative and less than
 503                                 // the size of the collection
 504                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 505                                 Assert.IsNull (ex.InnerException, "#C3");
 506                                 Assert.IsNotNull (ex.Message, "#C4");
 507                                 Assert.IsNotNull (ex.ParamName, "#C5");
 508                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 509                         }
 510                 }
 511
 512                 [Test]
 513                 public void TestUInt32 ()
 514                 {
 515                         PrivateTestUInt32 (0u);
 516                         PrivateTestUInt32 (1000u);
 517                         PrivateTestUInt32 (4294967295u);
 518                 }
 519
 520                 [Test]
 521                 public void ToUInt32_Value_Null ()
 522                 {
 523                         try {
 524                                 BitConverter.ToUInt32 ((byte []) null, 77);
 525                                 Assert.Fail ("#1");
 526                         } catch (ArgumentNullException ex) {
 527                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 528                                 Assert.IsNull (ex.InnerException, "#3");
 529                                 Assert.IsNotNull (ex.Message, "#4");
 530                                 Assert.IsNotNull (ex.ParamName, "#5");
 531                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 532                         }
 533                 }
 534
 535                 private void PrivateTestInt64 (long v1)
 536                 {
 537                         long v2;
 538                         byte [] b;
 539                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
 540
 541                         b = BitConverter.GetBytes (v1);
 542                         Assert.AreEqual (8, b.Length, "#A1");
 543
 544                         v2 = BitConverter.ToInt64 (b, 0);
 545                         Assert.AreEqual (v1, v2, "#A2");
 546
 547                         b.CopyTo (larger, 1);
 548                         v2 = BitConverter.ToInt64 (larger, 1);
 549                         Assert.AreEqual (v1, v2, "#A3");
 550
 551                         try {
 552                                 BitConverter.ToInt64 (larger, 8);
 553                                 Assert.Fail ("#B1");
 554                         } catch (ArgumentException ex) {
 555                                 // Destination array is not long enough to copy all the items
 556                                 // in the collection. Check array index and length
 557                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 558                                 Assert.IsNull (ex.InnerException, "#B3");
 559                                 Assert.IsNotNull (ex.Message, "#B4");
 560                                 Assert.IsNull (ex.ParamName, "#B5");
 561                         }
 562
 563                         try {
 564                                 BitConverter.ToInt64 (larger, 10);
 565                                 Assert.Fail ("#C1");
 566                         } catch (ArgumentOutOfRangeException ex) {
 567                                 // Index was out of range. Must be non-negative and less than
 568                                 // the size of the collection
 569                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 570                                 Assert.IsNull (ex.InnerException, "#C3");
 571                                 Assert.IsNotNull (ex.Message, "#C4");
 572                                 Assert.IsNotNull (ex.ParamName, "#C5");
 573                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 574                         }
 575                 }
 576
 577                 [Test]
 578                 public void TestInt64 ()
 579                 {
 580                         PrivateTestInt64 (0);
 581                         PrivateTestInt64 (1000);
 582                         PrivateTestInt64 (-9223372036854775808);
 583                         PrivateTestInt64 (9223372036854775807);
 584                 }
 585
 586                 [Test]
 587                 public void ToInt64_Value_Null ()
 588                 {
 589                         try {
 590                                 BitConverter.ToInt64 ((byte []) null, 77);
 591                                 Assert.Fail ("#1");
 592                         } catch (ArgumentNullException ex) {
 593                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 594                                 Assert.IsNull (ex.InnerException, "#3");
 595                                 Assert.IsNotNull (ex.Message, "#4");
 596                                 Assert.IsNotNull (ex.ParamName, "#5");
 597                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 598                         }
 599                 }
 600
 601                 private void PrivateTestUInt64 (ulong v1)
 602                 {
 603                         ulong v2;
 604                         byte [] b;
 605                         byte [] larger = new byte [] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 };
 606
 607                         b = BitConverter.GetBytes (v1);
 608                         Assert.AreEqual (8, b.Length, "#A1");
 609
 610                         v2 = BitConverter.ToUInt64 (b, 0);
 611                         Assert.AreEqual (v1, v2, "#A2");
 612
 613                         b.CopyTo (larger, 1);
 614                         v2 = BitConverter.ToUInt64 (larger, 1);
 615                         Assert.AreEqual (v1, v2, "#A3");
 616
 617                         try {
 618                                 BitConverter.ToUInt64 (larger, 8);
 619                                 Assert.Fail ("#B1");
 620                         } catch (ArgumentException ex) {
 621                                 // Destination array is not long enough to copy all the items
 622                                 // in the collection. Check array index and length
 623                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 624                                 Assert.IsNull (ex.InnerException, "#B3");
 625                                 Assert.IsNotNull (ex.Message, "#B4");
 626                                 Assert.IsNull (ex.ParamName, "#B5");
 627                         }
 628
 629                         try {
 630                                 BitConverter.ToUInt64 (larger, 10);
 631                                 Assert.Fail ("#C1");
 632                         } catch (ArgumentOutOfRangeException ex) {
 633                                 // Index was out of range. Must be non-negative and less than
 634                                 // the size of the collection
 635                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 636                                 Assert.IsNull (ex.InnerException, "#C3");
 637                                 Assert.IsNotNull (ex.Message, "#C4");
 638                                 Assert.IsNotNull (ex.ParamName, "#C5");
 639                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 640                         }
 641                 }
 642
 643                 [Test]
 644                 public void TestUInt64 ()
 645                 {
 646                         PrivateTestUInt64 (0);
 647                         PrivateTestUInt64 (1000);
 648                         PrivateTestUInt64 (18446744073709551615);
 649                 }
 650
 651                 [Test]
 652                 public void ToUInt64_Value_Null ()
 653                 {
 654                         try {
 655                                 BitConverter.ToUInt64 ((byte []) null, 77);
 656                                 Assert.Fail ("#1");
 657                         } catch (ArgumentNullException ex) {
 658                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 659                                 Assert.IsNull (ex.InnerException, "#3");
 660                                 Assert.IsNotNull (ex.Message, "#4");
 661                                 Assert.IsNotNull (ex.ParamName, "#5");
 662                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 663                         }
 664                 }
 665
 666                 [Test]
 667                 public void TestToString ()
 668                 {
 669                         byte [] b = new byte [] { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
 670
 671                         Assert.AreEqual ("00-11-22-33-44-55-66-77-88-99-AA-BB-CC-DD-EE-FF", BitConverter.ToString (b), "#A1");
 672                         Assert.AreEqual ("66-77-88-99-AA-BB-CC-DD-EE-FF", BitConverter.ToString (b, 6), "#A2");
 673                         Assert.AreEqual ("66-77-88", BitConverter.ToString (b, 6, 3), "#A3");
 674                         Assert.AreEqual (string.Empty, BitConverter.ToString (b, 6, 0), "#A4");
 675
 676                         try {
 677                                 BitConverter.ToString (b, 20);
 678                                 Assert.Fail ("#B1");
 679                         } catch (ArgumentOutOfRangeException ex) {
 680                                 // StartIndex cannot be less than zero
 681                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 682                                 Assert.IsNull (ex.InnerException, "#B3");
 683                                 Assert.IsNotNull (ex.Message, "#B4");
 684                                 Assert.IsNotNull (ex.ParamName, "#B5");
 685                                 Assert.AreEqual ("startIndex", ex.ParamName, "#B6");
 686                         }
 687
 688                         try {
 689                                 BitConverter.ToString (b, 20, 3);
 690                                 Assert.Fail ("#C1");
 691                         } catch (ArgumentOutOfRangeException ex) {
 692                                 // StartIndex cannot be less than zero
 693                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 694                                 Assert.IsNull (ex.InnerException, "#C3");
 695                                 Assert.IsNotNull (ex.Message, "#C4");
 696                                 Assert.IsNotNull (ex.ParamName, "#C5");
 697                                 Assert.AreEqual ("startIndex", ex.ParamName, "#C6");
 698                         }
 699
 700                         try {
 701                                 BitConverter.ToString (b, 16, 0);
 702                                 Assert.Fail ("#D1");
 703                         } catch (ArgumentOutOfRangeException ex) {
 704                                 // StartIndex cannot be less than zero
 705                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2");
 706                                 Assert.IsNull (ex.InnerException, "#D3");
 707                                 Assert.IsNotNull (ex.Message, "#D4");
 708                                 Assert.IsNotNull (ex.ParamName, "#D5");
 709                                 Assert.AreEqual ("startIndex", ex.ParamName, "#D6");
 710                         }
 711                 }
 712
 713                 [Test]
 714                 public void ToString_Value_Empty ()
 715                 {
 716                         byte [] empty = new byte [0];
 717                         Assert.AreEqual (String.Empty, BitConverter.ToString (empty), "#A1");
 718
 719                         try {
 720                                 BitConverter.ToString (empty, 3);
 721                                 Assert.Fail ("#B1");
 722                         } catch (ArgumentOutOfRangeException ex) {
 723                                 // StartIndex cannot be less than zero
 724                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 725                                 Assert.IsNull (ex.InnerException, "#B3");
 726                                 Assert.IsNotNull (ex.Message, "#B4");
 727                                 Assert.IsNotNull (ex.ParamName, "#B5");
 728                                 Assert.AreEqual ("startIndex", ex.ParamName, "#B6");
 729                         }
 730
 731                         Assert.AreEqual (String.Empty, BitConverter.ToString (empty, 0), "#C1");
 732
 733                         try {
 734                                 BitConverter.ToString (empty, 3, 0);
 735                                 Assert.Fail ("#D1");
 736                         } catch (ArgumentOutOfRangeException ex) {
 737                                 // StartIndex cannot be less than zero
 738                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#D2");
 739                                 Assert.IsNull (ex.InnerException, "#D3");
 740                                 Assert.IsNotNull (ex.Message, "#D4");
 741                                 Assert.IsNotNull (ex.ParamName, "#D5");
 742                                 Assert.AreEqual ("startIndex", ex.ParamName, "#D6");
 743                         }
 744
 745                         Assert.AreEqual (string.Empty, BitConverter.ToString (empty, 0, 0), "#E1");
 746
 747                         try {
 748                                 BitConverter.ToString (empty, 3, -1);
 749                                 Assert.Fail ("#F1");
 750                         } catch (ArgumentOutOfRangeException ex) {
 751                                 // StartIndex cannot be less than zero
 752                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#F2");
 753                                 Assert.IsNull (ex.InnerException, "#F3");
 754                                 Assert.IsNotNull (ex.Message, "#F4");
 755                                 Assert.IsNotNull (ex.ParamName, "#F5");
 756                                 Assert.AreEqual ("startIndex", ex.ParamName, "#F6");
 757                         }
 758                 }
 759
 760                 [Test]
 761                 public void ToString_Value_Null ()
 762                 {
 763                         try {
 764                                 BitConverter.ToString ((byte []) null);
 765                                 Assert.Fail ("#A1");
 766                         } catch (ArgumentNullException ex) {
 767                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 768                                 Assert.IsNull (ex.InnerException, "#A3");
 769                                 Assert.IsNotNull (ex.Message, "#A4");
 770                                 Assert.IsNotNull (ex.ParamName, "#A5");
 771                                 Assert.AreEqual ("value", ex.ParamName, "#A6");
 772                         }
 773
 774                         try {
 775                                 BitConverter.ToString ((byte []) null, 20);
 776                                 Assert.Fail ("#B1");
 777                         } catch (ArgumentNullException ex) {
 778                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 779                                 Assert.IsNull (ex.InnerException, "#B3");
 780                                 Assert.IsNotNull (ex.Message, "#B4");
 781                                 Assert.IsNotNull (ex.ParamName, "#B5");
 782                                 Assert.AreEqual ("value", ex.ParamName, "#B6");
 783                         }
 784
 785                         try {
 786                                 BitConverter.ToString ((byte []) null, 20, 3);
 787                                 Assert.Fail ("#C1");
 788                         } catch (ArgumentNullException ex) {
 789                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
 790                                 Assert.IsNull (ex.InnerException, "#C3");
 791                                 Assert.IsNotNull (ex.Message, "#C4");
 792                                 Assert.IsNotNull (ex.ParamName, "#C5");
 793                                 Assert.AreEqual ("value", ex.ParamName, "#C6");
 794                         }
 795                 }
 796
 797                 [Test]
 798                 public void ToString_StartIndex_Negative ()
 799                 {
 800                         try {
 801                                 BitConverter.ToString (new byte [0], -1);
 802                                 Assert.Fail ("#A1");
 803                         } catch (ArgumentOutOfRangeException ex) {
 804                                 // StartIndex cannot be less than zero
 805                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 806                                 Assert.IsNull (ex.InnerException, "#A3");
 807                                 Assert.IsNotNull (ex.Message, "#A4");
 808                                 Assert.IsNotNull (ex.ParamName, "#A5");
 809                                 Assert.AreEqual ("startIndex", ex.ParamName, "#A6");
 810                         }
 811
 812                         try {
 813                                 BitConverter.ToString (new byte [4], -1, 1);
 814                                 Assert.Fail ("#B1");
 815                         } catch (ArgumentOutOfRangeException ex) {
 816                                 // StartIndex cannot be less than zero
 817                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 818                                 Assert.IsNull (ex.InnerException, "#B3");
 819                                 Assert.IsNotNull (ex.Message, "#B4");
 820                                 Assert.IsNotNull (ex.ParamName, "#B5");
 821                                 Assert.AreEqual ("startIndex", ex.ParamName, "#B6");
 822                         }
 823                 }
 824
 825                 [Test]
 826                 public void ToString_StartIndex_Overflow ()
 827                 {
 828                         byte [] array = new byte [4];
 829                         try {
 830                                 BitConverter.ToString (array, Int32.MaxValue, 1);
 831                                 Assert.Fail ("#1");
 832                         } catch (ArgumentOutOfRangeException ex) {
 833                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 834                                 Assert.IsNull (ex.InnerException, "#3");
 835                                 Assert.IsNotNull (ex.Message, "#4");
 836                                 Assert.IsNotNull (ex.ParamName, "#5");
 837                                 Assert.AreEqual ("startIndex", ex.ParamName, "#6");
 838                         }
 839                 }
 840
 841                 [Test]
 842                 public void ToString_Length_Negative ()
 843                 {
 844                         byte [] array = new byte [4];
 845                         try {
 846                                 BitConverter.ToString (array, 1, -1);
 847                                 Assert.Fail ("#1");
 848                         } catch (ArgumentOutOfRangeException ex) {
 849                                 // Value must be positive
 850                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 851                                 Assert.IsNull (ex.InnerException, "#3");
 852                                 Assert.IsNotNull (ex.Message, "#4");
 853                                 Assert.IsNotNull (ex.ParamName, "#5");
 854                                 Assert.AreEqual ("length", ex.ParamName, "#6");
 855                         }
 856                 }
 857
 858                 [Test]
 859                 public void ToString_Length_Overflow ()
 860                 {
 861                         byte [] array = new byte [4];
 862                         try {
 863                                 BitConverter.ToString (array, 1, Int32.MaxValue);
 864                                 Assert.Fail ("#1");
 865                         } catch (ArgumentException ex) {
 866                                 // Destination array is not long enough to copy all the items
 867                                 // in the collection. Check array index and length
 868                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 869                                 Assert.IsNull (ex.InnerException, "#3");
 870                                 Assert.IsNotNull (ex.Message, "#4");
 871                                 Assert.IsNull (ex.ParamName, "#5");
 872                         }
 873                 }
 874
 875                 [Test]
 876                 public void ToInt32_UpperLimit ()
 877                 {
 878                         byte [] array = new byte [4];
 879                         try {
 880                                 BitConverter.ToInt32 (array, Int32.MaxValue);
 881                                 Assert.Fail ("#1");
 882                         } catch (ArgumentOutOfRangeException ex) {
 883                                 // Index was out of range. Must be non-negative and less than
 884                                 // the size of the collection
 885                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 886                                 Assert.IsNull (ex.InnerException, "#3");
 887                                 Assert.IsNotNull (ex.Message, "#4");
 888                                 Assert.IsNotNull (ex.ParamName, "#5");
 889                                 Assert.AreEqual ("startIndex", ex.ParamName, "#6");
 890                         }
 891                 }
 892
 893                 [Test]
 894                 public void ToInt32_LowerLimit ()
 895                 {
 896                         byte [] array = new byte [4];
 897                         try {
 898                                 BitConverter.ToInt32 (array, Int32.MinValue);
 899                                 Assert.Fail ("#1");
 900                         } catch (ArgumentOutOfRangeException ex) {
 901                                 // Index was out of range. Must be non-negative and less than
 902                                 // the size of the collection
 903                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 904                                 Assert.IsNull (ex.InnerException, "#3");
 905                                 Assert.IsNotNull (ex.Message, "#4");
 906                                 Assert.IsNotNull (ex.ParamName, "#5");
 907                                 Assert.AreEqual ("startIndex", ex.ParamName, "#6");
 908                         }
 909                 }
 910
 911                 [Test]
 912                 public void ToBoolean ()
 913                 {
 914                         byte [] array = new byte [2] { 0x02, 0x00 };
 915                         Assert.IsTrue (BitConverter.ToBoolean (array, 0), "#1");
 916                         Assert.IsFalse (BitConverter.ToBoolean (array, 1), "#2");
 917                 }
 918         }
 919 }