mcs/class/System.Drawing/Test/System.Drawing.Imaging/IconCodecTest.cs

   1 //
   2 // ICO Codec class testing unit
   3 //
   4 // Authors:
   5 //      Jordi Mas i Hernàndez (jordi@ximian.com)
   6 //      Sebastien Pouliot  <sebastien@ximian.com>
   7 //
   8 // Copyright (C) 2006-2007 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Drawing;
  32 using System.Drawing.Imaging;
  33 using System.IO;
  34 using System.Security.Permissions;
  35 using System.Text;
  36 using NUnit.Framework;
  37
  38 namespace MonoTests.System.Drawing.Imaging {
  39
  40         [TestFixture]
  41         [SecurityPermission (SecurityAction.Deny, UnmanagedCode = true)]
  42         public class IconCodecTest {
  43
  44                 /* Get suffix to add to the filename */
  45                 internal string getOutSufix ()
  46                 {
  47                         string s;
  48
  49                         int p = (int) Environment.OSVersion.Platform;
  50                         if ((p == 4) || (p == 128))
  51                                 s = "-unix";
  52                         else
  53                                 s = "-windows";
  54
  55                         if (Type.GetType ("Mono.Runtime", false) == null)
  56                                 s += "-msnet";
  57                         else
  58                                 s += "-mono";
  59
  60                         return s;
  61                 }
  62
  63                 /* Get the input directory depending on the runtime*/
  64                 internal string getInFile (string file)
  65                 {
  66                         string sRslt = Path.GetFullPath ("../System.Drawing/" + file);
  67
  68                         if (!File.Exists (sRslt))
  69                                 sRslt = "Test/System.Drawing/" + file;
  70
  71                         return sRslt;
  72                 }
  73
  74                 [Test]
  75                 public void Image16 ()
  76                 {
  77                         string sInFile = getInFile ("bitmaps/16x16x16.ico");
  78                         using (Image image = Image.FromFile (sInFile)) {
  79                                 Assert.IsTrue (image.RawFormat.Equals (ImageFormat.Icon), "Icon");
  80                                 // note that image is "promoted" to 32bits
  81                                 Assert.AreEqual (PixelFormat.Format32bppArgb, image.PixelFormat);
  82                                 Assert.AreEqual (73746, image.Flags, "bmp.Flags");
  83                                 Assert.AreEqual (16, image.Palette.Entries.Length, "Palette");
  84
  85                                 using (Bitmap bmp = new Bitmap (image)) {
  86                                         Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.MemoryBmp), "Icon");
  87                                         Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
  88                                         Assert.AreEqual (2, bmp.Flags, "bmp.Flags");
  89                                         Assert.AreEqual (0, bmp.Palette.Entries.Length, "Palette");
  90                                 }
  91                         }
  92                 }
  93
  94                 // simley.ico has 48x48, 32x32 and 16x16 images (in that order)
  95                 [Test]
  96                 public void Bitmap16Features ()
  97                 {
  98                         string sInFile = getInFile ("bitmaps/smiley.ico");
  99                         using (Bitmap bmp = new Bitmap (sInFile)) {
 100                                 GraphicsUnit unit = GraphicsUnit.World;
 101                                 RectangleF rect = bmp.GetBounds (ref unit);
 102
 103                                 Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.Icon), "Icon");
 104                                 // note that image is "promoted" to 32bits
 105                                 Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
 106                                 Assert.AreEqual (73746, bmp.Flags, "bmp.Flags");
 107                                 Assert.AreEqual (16, bmp.Palette.Entries.Length, "Palette");
 108                                 Assert.AreEqual (-16777216, bmp.Palette.Entries[0].ToArgb (), "Palette#0");
 109                                 Assert.AreEqual (-16777216, bmp.Palette.Entries[1].ToArgb (), "Palette#1");
 110                                 Assert.AreEqual (-16744448, bmp.Palette.Entries[2].ToArgb (), "Palette#2");
 111                                 Assert.AreEqual (-8355840, bmp.Palette.Entries[3].ToArgb (), "Palette#3");
 112                                 Assert.AreEqual (-16777088, bmp.Palette.Entries[4].ToArgb (), "Palette#4");
 113                                 Assert.AreEqual (-8388480, bmp.Palette.Entries[5].ToArgb (), "Palette#5");
 114                                 Assert.AreEqual (-16744320, bmp.Palette.Entries[6].ToArgb (), "Palette#6");
 115                                 Assert.AreEqual (-4144960, bmp.Palette.Entries[7].ToArgb (), "Palette#7");
 116                                 Assert.AreEqual (-8355712, bmp.Palette.Entries[8].ToArgb (), "Palette#8");
 117                                 Assert.AreEqual (-65536, bmp.Palette.Entries[9].ToArgb (), "Palette#9");
 118                                 Assert.AreEqual (-16711936, bmp.Palette.Entries[10].ToArgb (), "Palette#10");
 119                                 Assert.AreEqual (-256, bmp.Palette.Entries[11].ToArgb (), "Palette#11");
 120                                 Assert.AreEqual (-16776961, bmp.Palette.Entries[12].ToArgb (), "Palette#12");
 121                                 Assert.AreEqual (-65281, bmp.Palette.Entries[13].ToArgb (), "Palette#13");
 122                                 Assert.AreEqual (-16711681, bmp.Palette.Entries[14].ToArgb (), "Palette#14");
 123                                 Assert.AreEqual (-1, bmp.Palette.Entries[15].ToArgb (), "Palette#15");
 124                                 Assert.AreEqual (1, bmp.FrameDimensionsList.Length, "FrameDimensionsList");
 125                                 Assert.AreEqual (0, bmp.PropertyIdList.Length, "PropertyIdList");
 126                                 Assert.AreEqual (0, bmp.PropertyItems.Length, "PropertyItems");
 127 #if NET_2_0
 128                                 Assert.IsNull (bmp.Tag, "Tag");
 129 #endif
 130                                 Assert.AreEqual (96.0f, bmp.HorizontalResolution, "HorizontalResolution");
 131                                 Assert.AreEqual (96.0f, bmp.VerticalResolution, "VerticalResolution");
 132                                 Assert.AreEqual (16, bmp.Width, "bmp.Width");
 133                                 Assert.AreEqual (16, bmp.Height, "bmp.Height");
 134
 135                                 Assert.AreEqual (0, rect.X, "rect.X");
 136                                 Assert.AreEqual (0, rect.Y, "rect.Y");
 137                                 Assert.AreEqual (16, rect.Width, "rect.Width");
 138                                 Assert.AreEqual (16, rect.Height, "rect.Height");
 139
 140                                 Assert.AreEqual (16, bmp.Size.Width, "bmp.Size.Width");
 141                                 Assert.AreEqual (16, bmp.Size.Height, "bmp.Size.Height");
 142                         }
 143                 }
 144
 145                 [Test]
 146                 public void Bitmap16Pixels ()
 147                 {
 148                         string sInFile = getInFile ("bitmaps/smiley.ico");
 149                         using (Bitmap bmp = new Bitmap (sInFile)) {
 150 #if false
 151                                 for (int x = 0; x < bmp.Width; x += 4) {
 152                                         for (int y = 0; y < bmp.Height; y += 4)
 153                                                 Console.WriteLine ("\t\t\t\tAssert.AreEqual ({0}, bmp.GetPixel ({1}, {2}).ToArgb (), \"{1},{2}\");", bmp.GetPixel (x, y).ToArgb (), x, y);
 154                                 }
 155 #else
 156                                 // sampling values from a well known bitmap
 157                                 Assert.AreEqual (0, bmp.GetPixel (0, 0).ToArgb (), "0,0");
 158                                 Assert.AreEqual (0, bmp.GetPixel (0, 4).ToArgb (), "0,4");
 159                                 Assert.AreEqual (0, bmp.GetPixel (0, 8).ToArgb (), "0,8");
 160                                 Assert.AreEqual (0, bmp.GetPixel (0, 12).ToArgb (), "0,12");
 161                                 Assert.AreEqual (0, bmp.GetPixel (4, 0).ToArgb (), "4,0");
 162                                 Assert.AreEqual (-256, bmp.GetPixel (4, 4).ToArgb (), "4,4");
 163                                 Assert.AreEqual (-256, bmp.GetPixel (4, 8).ToArgb (), "4,8");
 164                                 Assert.AreEqual (-8355840, bmp.GetPixel (4, 12).ToArgb (), "4,12");
 165                                 Assert.AreEqual (0, bmp.GetPixel (8, 0).ToArgb (), "8,0");
 166                                 Assert.AreEqual (-256, bmp.GetPixel (8, 4).ToArgb (), "8,4");
 167                                 Assert.AreEqual (-256, bmp.GetPixel (8, 8).ToArgb (), "8,8");
 168                                 Assert.AreEqual (-256, bmp.GetPixel (8, 12).ToArgb (), "8,12");
 169                                 Assert.AreEqual (0, bmp.GetPixel (12, 0).ToArgb (), "12,0");
 170                                 Assert.AreEqual (0, bmp.GetPixel (12, 4).ToArgb (), "12,4");
 171                                 Assert.AreEqual (-8355840, bmp.GetPixel (12, 8).ToArgb (), "12,8");
 172                                 Assert.AreEqual (0, bmp.GetPixel (12, 12).ToArgb (), "12,12");
 173 #endif
 174                         }
 175                 }
 176
 177                 [Test]
 178                 public void Bitmat16Data ()
 179                 {
 180                         string sInFile = getInFile ("bitmaps/smiley.ico");
 181                         using (Bitmap bmp = new Bitmap (sInFile)) {
 182                                 BitmapData data = bmp.LockBits (new Rectangle (0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
 183                                 try {
 184                                         Assert.AreEqual (bmp.Height, data.Height, "Height");
 185                                         Assert.AreEqual (bmp.Width, data.Width, "Width");
 186                                         Assert.AreEqual (PixelFormat.Format24bppRgb, data.PixelFormat, "PixelFormat");
 187                                         int size = data.Height * data.Stride;
 188                                         unsafe {
 189                                                 byte* scan = (byte*) data.Scan0;
 190 #if false
 191                                                 // 13 is prime (so we're not affected by a recurring pattern)
 192                                                 for (int p = 0; p < size; p += 13) {
 193                                                         Console.WriteLine ("\t\t\t\t\t\tAssert.AreEqual ({0}, *(scan + {1}), \"{1}\");", *(scan + p), p);
 194                                                 }
 195 #else
 196                                                 // sampling values from a well known bitmap
 197                                                 Assert.AreEqual (0, *(scan + 0), "0");
 198                                                 Assert.AreEqual (0, *(scan + 13), "13");
 199                                                 Assert.AreEqual (0, *(scan + 26), "26");
 200                                                 Assert.AreEqual (0, *(scan + 39), "39");
 201                                                 Assert.AreEqual (0, *(scan + 52), "52");
 202                                                 Assert.AreEqual (0, *(scan + 65), "65");
 203                                                 Assert.AreEqual (0, *(scan + 78), "78");
 204                                                 Assert.AreEqual (0, *(scan + 91), "91");
 205                                                 Assert.AreEqual (0, *(scan + 104), "104");
 206                                                 Assert.AreEqual (0, *(scan + 117), "117");
 207                                                 Assert.AreEqual (0, *(scan + 130), "130");
 208                                                 Assert.AreEqual (0, *(scan + 143), "143");
 209                                                 Assert.AreEqual (0, *(scan + 156), "156");
 210                                                 Assert.AreEqual (255, *(scan + 169), "169");
 211                                                 Assert.AreEqual (0, *(scan + 182), "182");
 212                                                 Assert.AreEqual (0, *(scan + 195), "195");
 213                                                 Assert.AreEqual (255, *(scan + 208), "208");
 214                                                 Assert.AreEqual (255, *(scan + 221), "221");
 215                                                 Assert.AreEqual (0, *(scan + 234), "234");
 216                                                 Assert.AreEqual (128, *(scan + 247), "247");
 217                                                 Assert.AreEqual (0, *(scan + 260), "260");
 218                                                 Assert.AreEqual (0, *(scan + 273), "273");
 219                                                 Assert.AreEqual (0, *(scan + 286), "286");
 220                                                 Assert.AreEqual (255, *(scan + 299), "299");
 221                                                 Assert.AreEqual (0, *(scan + 312), "312");
 222                                                 Assert.AreEqual (128, *(scan + 325), "325");
 223                                                 Assert.AreEqual (0, *(scan + 338), "338");
 224                                                 Assert.AreEqual (0, *(scan + 351), "351");
 225                                                 Assert.AreEqual (255, *(scan + 364), "364");
 226                                                 Assert.AreEqual (0, *(scan + 377), "377");
 227                                                 Assert.AreEqual (0, *(scan + 390), "390");
 228                                                 Assert.AreEqual (255, *(scan + 403), "403");
 229                                                 Assert.AreEqual (255, *(scan + 416), "416");
 230                                                 Assert.AreEqual (0, *(scan + 429), "429");
 231                                                 Assert.AreEqual (255, *(scan + 442), "442");
 232                                                 Assert.AreEqual (0, *(scan + 455), "455");
 233                                                 Assert.AreEqual (0, *(scan + 468), "468");
 234                                                 Assert.AreEqual (0, *(scan + 481), "481");
 235                                                 Assert.AreEqual (255, *(scan + 494), "494");
 236                                                 Assert.AreEqual (0, *(scan + 507), "507");
 237                                                 Assert.AreEqual (0, *(scan + 520), "520");
 238                                                 Assert.AreEqual (0, *(scan + 533), "533");
 239                                                 Assert.AreEqual (0, *(scan + 546), "546");
 240                                                 Assert.AreEqual (255, *(scan + 559), "559");
 241                                                 Assert.AreEqual (0, *(scan + 572), "572");
 242                                                 Assert.AreEqual (0, *(scan + 585), "585");
 243                                                 Assert.AreEqual (255, *(scan + 598), "598");
 244                                                 Assert.AreEqual (0, *(scan + 611), "611");
 245                                                 Assert.AreEqual (0, *(scan + 624), "624");
 246                                                 Assert.AreEqual (0, *(scan + 637), "637");
 247                                                 Assert.AreEqual (128, *(scan + 650), "650");
 248                                                 Assert.AreEqual (0, *(scan + 663), "663");
 249                                                 Assert.AreEqual (0, *(scan + 676), "676");
 250                                                 Assert.AreEqual (0, *(scan + 689), "689");
 251                                                 Assert.AreEqual (0, *(scan + 702), "702");
 252                                                 Assert.AreEqual (0, *(scan + 715), "715");
 253                                                 Assert.AreEqual (0, *(scan + 728), "728");
 254                                                 Assert.AreEqual (0, *(scan + 741), "741");
 255                                                 Assert.AreEqual (0, *(scan + 754), "754");
 256                                                 Assert.AreEqual (0, *(scan + 767), "767");
 257 #endif
 258                                         }
 259                                 }
 260                                 finally {
 261                                         bmp.UnlockBits (data);
 262                                 }
 263                         }
 264                 }
 265
 266                 // VisualPng.ico only has a 32x32 size available
 267                 [Test]
 268                 public void Bitmap32Features ()
 269                 {
 270                         string sInFile = getInFile ("bitmaps/VisualPng.ico");
 271                         using (Bitmap bmp = new Bitmap (sInFile)) {
 272                                 GraphicsUnit unit = GraphicsUnit.World;
 273                                 RectangleF rect = bmp.GetBounds (ref unit);
 274
 275                                 Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.Icon), "Icon");
 276                                 Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
 277                                 Assert.AreEqual (73746, bmp.Flags, "bmp.Flags");
 278                                 Assert.AreEqual (16, bmp.Palette.Entries.Length, "Palette");
 279                                 Assert.AreEqual (-16777216, bmp.Palette.Entries[0].ToArgb (), "Palette#0");
 280                                 Assert.AreEqual (-8388608, bmp.Palette.Entries[1].ToArgb (), "Palette#1");
 281                                 Assert.AreEqual (-16744448, bmp.Palette.Entries[2].ToArgb (), "Palette#2");
 282                                 Assert.AreEqual (-8355840, bmp.Palette.Entries[3].ToArgb (), "Palette#3");
 283                                 Assert.AreEqual (-16777088, bmp.Palette.Entries[4].ToArgb (), "Palette#4");
 284                                 Assert.AreEqual (-8388480, bmp.Palette.Entries[5].ToArgb (), "Palette#5");
 285                                 Assert.AreEqual (-16744320, bmp.Palette.Entries[6].ToArgb (), "Palette#6");
 286                                 Assert.AreEqual (-4144960, bmp.Palette.Entries[7].ToArgb (), "Palette#7");
 287                                 Assert.AreEqual (-8355712, bmp.Palette.Entries[8].ToArgb (), "Palette#8");
 288                                 Assert.AreEqual (-65536, bmp.Palette.Entries[9].ToArgb (), "Palette#9");
 289                                 Assert.AreEqual (-16711936, bmp.Palette.Entries[10].ToArgb (), "Palette#10");
 290                                 Assert.AreEqual (-256, bmp.Palette.Entries[11].ToArgb (), "Palette#11");
 291                                 Assert.AreEqual (-16776961, bmp.Palette.Entries[12].ToArgb (), "Palette#12");
 292                                 Assert.AreEqual (-65281, bmp.Palette.Entries[13].ToArgb (), "Palette#13");
 293                                 Assert.AreEqual (-16711681, bmp.Palette.Entries[14].ToArgb (), "Palette#14");
 294                                 Assert.AreEqual (-1, bmp.Palette.Entries[15].ToArgb (), "Palette#15");
 295                                 Assert.AreEqual (1, bmp.FrameDimensionsList.Length, "FrameDimensionsList");
 296                                 Assert.AreEqual (0, bmp.PropertyIdList.Length, "PropertyIdList");
 297                                 Assert.AreEqual (0, bmp.PropertyItems.Length, "PropertyItems");
 298 #if NET_2_0
 299                                 Assert.IsNull (bmp.Tag, "Tag");
 300 #endif
 301                                 Assert.AreEqual (96.0f, bmp.HorizontalResolution, "HorizontalResolution");
 302                                 Assert.AreEqual (96.0f, bmp.VerticalResolution, "VerticalResolution");
 303                                 Assert.AreEqual (32, bmp.Width, "bmp.Width");
 304                                 Assert.AreEqual (32, bmp.Height, "bmp.Height");
 305
 306                                 Assert.AreEqual (0, rect.X, "rect.X");
 307                                 Assert.AreEqual (0, rect.Y, "rect.Y");
 308                                 Assert.AreEqual (32, rect.Width, "rect.Width");
 309                                 Assert.AreEqual (32, rect.Height, "rect.Height");
 310
 311                                 Assert.AreEqual (32, bmp.Size.Width, "bmp.Size.Width");
 312                                 Assert.AreEqual (32, bmp.Size.Height, "bmp.Size.Height");
 313                         }
 314                 }
 315
 316                 [Test]
 317                 public void Bitmap32Pixels ()
 318                 {
 319                         string sInFile = getInFile ("bitmaps/VisualPng.ico");
 320                         using (Bitmap bmp = new Bitmap (sInFile)) {
 321 #if false
 322                                 for (int x = 0; x < bmp.Width; x += 4) {
 323                                         for (int y = 0; y < bmp.Height; y += 4)
 324                                                 Console.WriteLine ("\t\t\t\tAssert.AreEqual ({0}, bmp.GetPixel ({1}, {2}).ToArgb (), \"{1},{2}\");", bmp.GetPixel (x, y).ToArgb (), x, y);
 325                                 }
 326 #else
 327                                 // sampling values from a well known bitmap
 328                                 Assert.AreEqual (0, bmp.GetPixel (0, 0).ToArgb (), "0,0");
 329                                 Assert.AreEqual (-8388608, bmp.GetPixel (0, 4).ToArgb (), "0,4");
 330                                 Assert.AreEqual (0, bmp.GetPixel (0, 8).ToArgb (), "0,8");
 331                                 Assert.AreEqual (0, bmp.GetPixel (0, 12).ToArgb (), "0,12");
 332                                 Assert.AreEqual (0, bmp.GetPixel (0, 16).ToArgb (), "0,16");
 333                                 Assert.AreEqual (0, bmp.GetPixel (0, 20).ToArgb (), "0,20");
 334                                 Assert.AreEqual (0, bmp.GetPixel (0, 24).ToArgb (), "0,24");
 335                                 Assert.AreEqual (0, bmp.GetPixel (0, 28).ToArgb (), "0,28");
 336                                 Assert.AreEqual (0, bmp.GetPixel (4, 0).ToArgb (), "4,0");
 337                                 Assert.AreEqual (0, bmp.GetPixel (4, 4).ToArgb (), "4,4");
 338                                 Assert.AreEqual (0, bmp.GetPixel (4, 8).ToArgb (), "4,8");
 339                                 Assert.AreEqual (0, bmp.GetPixel (4, 12).ToArgb (), "4,12");
 340                                 Assert.AreEqual (0, bmp.GetPixel (4, 16).ToArgb (), "4,16");
 341                                 Assert.AreEqual (0, bmp.GetPixel (4, 20).ToArgb (), "4,20");
 342                                 Assert.AreEqual (0, bmp.GetPixel (4, 24).ToArgb (), "4,24");
 343                                 Assert.AreEqual (0, bmp.GetPixel (4, 28).ToArgb (), "4,28");
 344                                 Assert.AreEqual (0, bmp.GetPixel (8, 0).ToArgb (), "8,0");
 345                                 Assert.AreEqual (0, bmp.GetPixel (8, 4).ToArgb (), "8,4");
 346                                 Assert.AreEqual (0, bmp.GetPixel (8, 8).ToArgb (), "8,8");
 347                                 Assert.AreEqual (0, bmp.GetPixel (8, 12).ToArgb (), "8,12");
 348                                 Assert.AreEqual (0, bmp.GetPixel (8, 16).ToArgb (), "8,16");
 349                                 Assert.AreEqual (-65536, bmp.GetPixel (8, 20).ToArgb (), "8,20");
 350                                 Assert.AreEqual (0, bmp.GetPixel (8, 24).ToArgb (), "8,24");
 351                                 Assert.AreEqual (0, bmp.GetPixel (8, 28).ToArgb (), "8,28");
 352                                 Assert.AreEqual (0, bmp.GetPixel (12, 0).ToArgb (), "12,0");
 353                                 Assert.AreEqual (0, bmp.GetPixel (12, 4).ToArgb (), "12,4");
 354                                 Assert.AreEqual (-8388608, bmp.GetPixel (12, 8).ToArgb (), "12,8");
 355                                 Assert.AreEqual (0, bmp.GetPixel (12, 12).ToArgb (), "12,12");
 356                                 Assert.AreEqual (0, bmp.GetPixel (12, 16).ToArgb (), "12,16");
 357                                 Assert.AreEqual (-65536, bmp.GetPixel (12, 20).ToArgb (), "12,20");
 358                                 Assert.AreEqual (0, bmp.GetPixel (12, 24).ToArgb (), "12,24");
 359                                 Assert.AreEqual (0, bmp.GetPixel (12, 28).ToArgb (), "12,28");
 360                                 Assert.AreEqual (0, bmp.GetPixel (16, 0).ToArgb (), "16,0");
 361                                 Assert.AreEqual (0, bmp.GetPixel (16, 4).ToArgb (), "16,4");
 362                                 Assert.AreEqual (0, bmp.GetPixel (16, 8).ToArgb (), "16,8");
 363                                 Assert.AreEqual (0, bmp.GetPixel (16, 12).ToArgb (), "16,12");
 364                                 Assert.AreEqual (0, bmp.GetPixel (16, 16).ToArgb (), "16,16");
 365                                 Assert.AreEqual (0, bmp.GetPixel (16, 20).ToArgb (), "16,20");
 366                                 Assert.AreEqual (-65536, bmp.GetPixel (16, 24).ToArgb (), "16,24");
 367                                 Assert.AreEqual (0, bmp.GetPixel (16, 28).ToArgb (), "16,28");
 368                                 Assert.AreEqual (0, bmp.GetPixel (20, 0).ToArgb (), "20,0");
 369                                 Assert.AreEqual (0, bmp.GetPixel (20, 4).ToArgb (), "20,4");
 370                                 Assert.AreEqual (-8388608, bmp.GetPixel (20, 8).ToArgb (), "20,8");
 371                                 Assert.AreEqual (0, bmp.GetPixel (20, 12).ToArgb (), "20,12");
 372                                 Assert.AreEqual (0, bmp.GetPixel (20, 16).ToArgb (), "20,16");
 373                                 Assert.AreEqual (0, bmp.GetPixel (20, 20).ToArgb (), "20,20");
 374                                 Assert.AreEqual (0, bmp.GetPixel (20, 24).ToArgb (), "20,24");
 375                                 Assert.AreEqual (0, bmp.GetPixel (20, 28).ToArgb (), "20,28");
 376                                 Assert.AreEqual (0, bmp.GetPixel (24, 0).ToArgb (), "24,0");
 377                                 Assert.AreEqual (0, bmp.GetPixel (24, 4).ToArgb (), "24,4");
 378                                 Assert.AreEqual (-16777216, bmp.GetPixel (24, 8).ToArgb (), "24,8");
 379                                 Assert.AreEqual (0, bmp.GetPixel (24, 12).ToArgb (), "24,12");
 380                                 Assert.AreEqual (0, bmp.GetPixel (24, 16).ToArgb (), "24,16");
 381                                 Assert.AreEqual (0, bmp.GetPixel (24, 20).ToArgb (), "24,20");
 382                                 Assert.AreEqual (0, bmp.GetPixel (24, 24).ToArgb (), "24,24");
 383                                 Assert.AreEqual (0, bmp.GetPixel (24, 28).ToArgb (), "24,28");
 384                                 Assert.AreEqual (0, bmp.GetPixel (28, 0).ToArgb (), "28,0");
 385                                 Assert.AreEqual (0, bmp.GetPixel (28, 4).ToArgb (), "28,4");
 386                                 Assert.AreEqual (0, bmp.GetPixel (28, 8).ToArgb (), "28,8");
 387                                 Assert.AreEqual (0, bmp.GetPixel (28, 12).ToArgb (), "28,12");
 388                                 Assert.AreEqual (0, bmp.GetPixel (28, 16).ToArgb (), "28,16");
 389                                 Assert.AreEqual (0, bmp.GetPixel (28, 20).ToArgb (), "28,20");
 390                                 Assert.AreEqual (-8388608, bmp.GetPixel (28, 24).ToArgb (), "28,24");
 391                                 Assert.AreEqual (0, bmp.GetPixel (28, 28).ToArgb (), "28,28");
 392 #endif
 393                         }
 394                 }
 395
 396                 [Test]
 397                 public void Bitmat32Data ()
 398                 {
 399                         string sInFile = getInFile ("bitmaps/VisualPng.ico");
 400                         using (Bitmap bmp = new Bitmap (sInFile)) {
 401                                 BitmapData data = bmp.LockBits (new Rectangle (0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
 402                                 try {
 403                                         Assert.AreEqual (bmp.Height, data.Height, "Height");
 404                                         Assert.AreEqual (bmp.Width, data.Width, "Width");
 405                                         Assert.AreEqual (PixelFormat.Format24bppRgb, data.PixelFormat, "PixelFormat");
 406                                         int size = data.Height * data.Stride;
 407                                         unsafe {
 408                                                 byte* scan = (byte*) data.Scan0;
 409 #if false
 410                                                 // 13 is prime (so we're not affected by a recurring pattern)
 411                                                 for (int p = 0; p < size; p += 13) {
 412                                                         Console.WriteLine ("\t\t\t\t\t\tAssert.AreEqual ({0}, *(scan + {1}), \"{1}\");", *(scan + p), p);
 413                                                 }
 414 #else
 415                                                 // sampling values from a well known bitmap
 416                                                 Assert.AreEqual (0, *(scan + 0), "0");
 417                                                 Assert.AreEqual (0, *(scan + 13), "13");
 418                                                 Assert.AreEqual (0, *(scan + 26), "26");
 419                                                 Assert.AreEqual (0, *(scan + 39), "39");
 420                                                 Assert.AreEqual (0, *(scan + 52), "52");
 421                                                 Assert.AreEqual (0, *(scan + 65), "65");
 422                                                 Assert.AreEqual (0, *(scan + 78), "78");
 423                                                 Assert.AreEqual (0, *(scan + 91), "91");
 424                                                 Assert.AreEqual (0, *(scan + 104), "104");
 425                                                 Assert.AreEqual (0, *(scan + 117), "117");
 426                                                 Assert.AreEqual (0, *(scan + 130), "130");
 427                                                 Assert.AreEqual (0, *(scan + 143), "143");
 428                                                 Assert.AreEqual (0, *(scan + 156), "156");
 429                                                 Assert.AreEqual (0, *(scan + 169), "169");
 430                                                 Assert.AreEqual (0, *(scan + 182), "182");
 431                                                 Assert.AreEqual (0, *(scan + 195), "195");
 432                                                 Assert.AreEqual (0, *(scan + 208), "208");
 433                                                 Assert.AreEqual (0, *(scan + 221), "221");
 434                                                 Assert.AreEqual (0, *(scan + 234), "234");
 435                                                 Assert.AreEqual (0, *(scan + 247), "247");
 436                                                 Assert.AreEqual (0, *(scan + 260), "260");
 437                                                 Assert.AreEqual (0, *(scan + 273), "273");
 438                                                 Assert.AreEqual (0, *(scan + 286), "286");
 439                                                 Assert.AreEqual (0, *(scan + 299), "299");
 440                                                 Assert.AreEqual (0, *(scan + 312), "312");
 441                                                 Assert.AreEqual (0, *(scan + 325), "325");
 442                                                 Assert.AreEqual (0, *(scan + 338), "338");
 443                                                 Assert.AreEqual (0, *(scan + 351), "351");
 444                                                 Assert.AreEqual (0, *(scan + 364), "364");
 445                                                 Assert.AreEqual (0, *(scan + 377), "377");
 446                                                 Assert.AreEqual (0, *(scan + 390), "390");
 447                                                 Assert.AreEqual (0, *(scan + 403), "403");
 448                                                 Assert.AreEqual (0, *(scan + 416), "416");
 449                                                 Assert.AreEqual (0, *(scan + 429), "429");
 450                                                 Assert.AreEqual (0, *(scan + 442), "442");
 451                                                 Assert.AreEqual (0, *(scan + 455), "455");
 452                                                 Assert.AreEqual (0, *(scan + 468), "468");
 453                                                 Assert.AreEqual (0, *(scan + 481), "481");
 454                                                 Assert.AreEqual (128, *(scan + 494), "494");
 455                                                 Assert.AreEqual (0, *(scan + 507), "507");
 456                                                 Assert.AreEqual (0, *(scan + 520), "520");
 457                                                 Assert.AreEqual (0, *(scan + 533), "533");
 458                                                 Assert.AreEqual (0, *(scan + 546), "546");
 459                                                 Assert.AreEqual (0, *(scan + 559), "559");
 460                                                 Assert.AreEqual (128, *(scan + 572), "572");
 461                                                 Assert.AreEqual (0, *(scan + 585), "585");
 462                                                 Assert.AreEqual (0, *(scan + 598), "598");
 463                                                 Assert.AreEqual (0, *(scan + 611), "611");
 464                                                 Assert.AreEqual (0, *(scan + 624), "624");
 465                                                 Assert.AreEqual (0, *(scan + 637), "637");
 466                                                 Assert.AreEqual (128, *(scan + 650), "650");
 467                                                 Assert.AreEqual (0, *(scan + 663), "663");
 468                                                 Assert.AreEqual (0, *(scan + 676), "676");
 469                                                 Assert.AreEqual (0, *(scan + 689), "689");
 470                                                 Assert.AreEqual (0, *(scan + 702), "702");
 471                                                 Assert.AreEqual (0, *(scan + 715), "715");
 472                                                 Assert.AreEqual (0, *(scan + 728), "728");
 473                                                 Assert.AreEqual (0, *(scan + 741), "741");
 474                                                 Assert.AreEqual (0, *(scan + 754), "754");
 475                                                 Assert.AreEqual (0, *(scan + 767), "767");
 476                                                 Assert.AreEqual (0, *(scan + 780), "780");
 477                                                 Assert.AreEqual (0, *(scan + 793), "793");
 478                                                 Assert.AreEqual (128, *(scan + 806), "806");
 479                                                 Assert.AreEqual (0, *(scan + 819), "819");
 480                                                 Assert.AreEqual (0, *(scan + 832), "832");
 481                                                 Assert.AreEqual (128, *(scan + 845), "845");
 482                                                 Assert.AreEqual (0, *(scan + 858), "858");
 483                                                 Assert.AreEqual (0, *(scan + 871), "871");
 484                                                 Assert.AreEqual (0, *(scan + 884), "884");
 485 #endif
 486                                         }
 487                                 }
 488                                 finally {
 489                                         bmp.UnlockBits (data);
 490                                 }
 491                         }
 492                 }
 493
 494                 // 48x48x1.ico only has a 48x48 size available
 495                 [Test]
 496                 public void Bitmap48Features ()
 497                 {
 498                         string sInFile = getInFile ("bitmaps/48x48x1.ico");
 499                         using (Bitmap bmp = new Bitmap (sInFile)) {
 500                                 GraphicsUnit unit = GraphicsUnit.World;
 501                                 RectangleF rect = bmp.GetBounds (ref unit);
 502
 503                                 Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.Icon), "Icon");
 504                                 Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
 505                                 Assert.AreEqual (73746, bmp.Flags, "bmp.Flags");
 506                                 Assert.AreEqual (2, bmp.Palette.Entries.Length, "Palette");
 507                                 Assert.AreEqual (-16777216, bmp.Palette.Entries[0].ToArgb (), "Palette#0");
 508                                 Assert.AreEqual (-1, bmp.Palette.Entries[1].ToArgb (), "Palette#1");
 509                                 Assert.AreEqual (1, bmp.FrameDimensionsList.Length, "FrameDimensionsList");
 510                                 Assert.AreEqual (0, bmp.PropertyIdList.Length, "PropertyIdList");
 511                                 Assert.AreEqual (0, bmp.PropertyItems.Length, "PropertyItems");
 512 #if NET_2_0
 513                                 Assert.IsNull (bmp.Tag, "Tag");
 514 #endif
 515                                 Assert.AreEqual (96.0f, bmp.HorizontalResolution, "HorizontalResolution");
 516                                 Assert.AreEqual (96.0f, bmp.VerticalResolution, "VerticalResolution");
 517                                 Assert.AreEqual (48, bmp.Width, "bmp.Width");
 518                                 Assert.AreEqual (48, bmp.Height, "bmp.Height");
 519
 520                                 Assert.AreEqual (0, rect.X, "rect.X");
 521                                 Assert.AreEqual (0, rect.Y, "rect.Y");
 522                                 Assert.AreEqual (48, rect.Width, "rect.Width");
 523                                 Assert.AreEqual (48, rect.Height, "rect.Height");
 524
 525                                 Assert.AreEqual (48, bmp.Size.Width, "bmp.Size.Width");
 526                                 Assert.AreEqual (48, bmp.Size.Height, "bmp.Size.Height");
 527                         }
 528                 }
 529
 530                 [Test]
 531                 public void Bitmap48Pixels ()
 532                 {
 533                         string sInFile = getInFile ("bitmaps/48x48x1.ico");
 534                         using (Bitmap bmp = new Bitmap (sInFile)) {
 535 #if false
 536                                 for (int x = 0; x < bmp.Width; x += 4) {
 537                                         for (int y = 0; y < bmp.Height; y += 4)
 538                                                 Console.WriteLine ("\t\t\t\tAssert.AreEqual ({0}, bmp.GetPixel ({1}, {2}).ToArgb (), \"{1},{2}\");", bmp.GetPixel (x, y).ToArgb (), x, y);
 539                                 }
 540 #else
 541                                 // sampling values from a well known bitmap
 542                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 0).ToArgb (), "0,0");
 543                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 4).ToArgb (), "0,4");
 544                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 8).ToArgb (), "0,8");
 545                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 12).ToArgb (), "0,12");
 546                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 16).ToArgb (), "0,16");
 547                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 20).ToArgb (), "0,20");
 548                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 24).ToArgb (), "0,24");
 549                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 28).ToArgb (), "0,28");
 550                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 32).ToArgb (), "0,32");
 551                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 36).ToArgb (), "0,36");
 552                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 40).ToArgb (), "0,40");
 553                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 44).ToArgb (), "0,44");
 554                                 Assert.AreEqual (-16777216, bmp.GetPixel (4, 0).ToArgb (), "4,0");
 555                                 Assert.AreEqual (0, bmp.GetPixel (4, 4).ToArgb (), "4,4");
 556                                 Assert.AreEqual (0, bmp.GetPixel (4, 8).ToArgb (), "4,8");
 557                                 Assert.AreEqual (0, bmp.GetPixel (4, 12).ToArgb (), "4,12");
 558                                 Assert.AreEqual (0, bmp.GetPixel (4, 16).ToArgb (), "4,16");
 559                                 Assert.AreEqual (0, bmp.GetPixel (4, 20).ToArgb (), "4,20");
 560                                 Assert.AreEqual (0, bmp.GetPixel (4, 24).ToArgb (), "4,24");
 561                                 Assert.AreEqual (0, bmp.GetPixel (4, 28).ToArgb (), "4,28");
 562                                 Assert.AreEqual (0, bmp.GetPixel (4, 32).ToArgb (), "4,32");
 563                                 Assert.AreEqual (0, bmp.GetPixel (4, 36).ToArgb (), "4,36");
 564                                 Assert.AreEqual (0, bmp.GetPixel (4, 40).ToArgb (), "4,40");
 565                                 Assert.AreEqual (-1, bmp.GetPixel (4, 44).ToArgb (), "4,44");
 566                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 0).ToArgb (), "8,0");
 567                                 Assert.AreEqual (0, bmp.GetPixel (8, 4).ToArgb (), "8,4");
 568                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 8).ToArgb (), "8,8");
 569                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 12).ToArgb (), "8,12");
 570                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 16).ToArgb (), "8,16");
 571                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 20).ToArgb (), "8,20");
 572                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 24).ToArgb (), "8,24");
 573                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 28).ToArgb (), "8,28");
 574                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 32).ToArgb (), "8,32");
 575                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 36).ToArgb (), "8,36");
 576                                 Assert.AreEqual (-16777216, bmp.GetPixel (8, 40).ToArgb (), "8,40");
 577                                 Assert.AreEqual (-1, bmp.GetPixel (8, 44).ToArgb (), "8,44");
 578                                 Assert.AreEqual (-16777216, bmp.GetPixel (12, 0).ToArgb (), "12,0");
 579                                 Assert.AreEqual (0, bmp.GetPixel (12, 4).ToArgb (), "12,4");
 580                                 Assert.AreEqual (-16777216, bmp.GetPixel (12, 8).ToArgb (), "12,8");
 581                                 Assert.AreEqual (-1, bmp.GetPixel (12, 12).ToArgb (), "12,12");
 582                                 Assert.AreEqual (-1, bmp.GetPixel (12, 16).ToArgb (), "12,16");
 583                                 Assert.AreEqual (-1, bmp.GetPixel (12, 20).ToArgb (), "12,20");
 584                                 Assert.AreEqual (-1, bmp.GetPixel (12, 24).ToArgb (), "12,24");
 585                                 Assert.AreEqual (-1, bmp.GetPixel (12, 28).ToArgb (), "12,28");
 586                                 Assert.AreEqual (-1, bmp.GetPixel (12, 32).ToArgb (), "12,32");
 587                                 Assert.AreEqual (0, bmp.GetPixel (12, 36).ToArgb (), "12,36");
 588                                 Assert.AreEqual (-16777216, bmp.GetPixel (12, 40).ToArgb (), "12,40");
 589                                 Assert.AreEqual (-1, bmp.GetPixel (12, 44).ToArgb (), "12,44");
 590                                 Assert.AreEqual (-16777216, bmp.GetPixel (16, 0).ToArgb (), "16,0");
 591                                 Assert.AreEqual (0, bmp.GetPixel (16, 4).ToArgb (), "16,4");
 592                                 Assert.AreEqual (-16777216, bmp.GetPixel (16, 8).ToArgb (), "16,8");
 593                                 Assert.AreEqual (-1, bmp.GetPixel (16, 12).ToArgb (), "16,12");
 594                                 Assert.AreEqual (0, bmp.GetPixel (16, 16).ToArgb (), "16,16");
 595                                 Assert.AreEqual (0, bmp.GetPixel (16, 20).ToArgb (), "16,20");
 596                                 Assert.AreEqual (0, bmp.GetPixel (16, 24).ToArgb (), "16,24");
 597                                 Assert.AreEqual (0, bmp.GetPixel (16, 28).ToArgb (), "16,28");
 598                                 Assert.AreEqual (-1, bmp.GetPixel (16, 32).ToArgb (), "16,32");
 599                                 Assert.AreEqual (0, bmp.GetPixel (16, 36).ToArgb (), "16,36");
 600                                 Assert.AreEqual (-16777216, bmp.GetPixel (16, 40).ToArgb (), "16,40");
 601                                 Assert.AreEqual (-1, bmp.GetPixel (16, 44).ToArgb (), "16,44");
 602                                 Assert.AreEqual (-16777216, bmp.GetPixel (20, 0).ToArgb (), "20,0");
 603                                 Assert.AreEqual (0, bmp.GetPixel (20, 4).ToArgb (), "20,4");
 604                                 Assert.AreEqual (-16777216, bmp.GetPixel (20, 8).ToArgb (), "20,8");
 605                                 Assert.AreEqual (-1, bmp.GetPixel (20, 12).ToArgb (), "20,12");
 606                                 Assert.AreEqual (0, bmp.GetPixel (20, 16).ToArgb (), "20,16");
 607                                 Assert.AreEqual (-16777216, bmp.GetPixel (20, 20).ToArgb (), "20,20");
 608                                 Assert.AreEqual (-16777216, bmp.GetPixel (20, 24).ToArgb (), "20,24");
 609                                 Assert.AreEqual (0, bmp.GetPixel (20, 28).ToArgb (), "20,28");
 610                                 Assert.AreEqual (-1, bmp.GetPixel (20, 32).ToArgb (), "20,32");
 611                                 Assert.AreEqual (0, bmp.GetPixel (20, 36).ToArgb (), "20,36");
 612                                 Assert.AreEqual (-16777216, bmp.GetPixel (20, 40).ToArgb (), "20,40");
 613                                 Assert.AreEqual (-1, bmp.GetPixel (20, 44).ToArgb (), "20,44");
 614                                 Assert.AreEqual (-16777216, bmp.GetPixel (24, 0).ToArgb (), "24,0");
 615                                 Assert.AreEqual (0, bmp.GetPixel (24, 4).ToArgb (), "24,4");
 616                                 Assert.AreEqual (-16777216, bmp.GetPixel (24, 8).ToArgb (), "24,8");
 617                                 Assert.AreEqual (-1, bmp.GetPixel (24, 12).ToArgb (), "24,12");
 618                                 Assert.AreEqual (0, bmp.GetPixel (24, 16).ToArgb (), "24,16");
 619 #endif
 620                         }
 621                 }
 622
 623                 [Test]
 624                 public void Bitmat48Data ()
 625                 {
 626                         string sInFile = getInFile ("bitmaps/48x48x1.ico");
 627                         using (Bitmap bmp = new Bitmap (sInFile)) {
 628                                 BitmapData data = bmp.LockBits (new Rectangle (0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
 629                                 try {
 630                                         Assert.AreEqual (bmp.Height, data.Height, "Height");
 631                                         Assert.AreEqual (bmp.Width, data.Width, "Width");
 632                                         Assert.AreEqual (PixelFormat.Format24bppRgb, data.PixelFormat, "PixelFormat");
 633                                         int size = data.Height * data.Stride;
 634                                         unsafe {
 635                                                 byte* scan = (byte*) data.Scan0;
 636 #if false
 637                                                 // 13 is prime (so we're not affected by a recurring pattern)
 638                                                 for (int p = 0; p < size; p += 13) {
 639                                                         Console.WriteLine ("\t\t\t\t\t\tAssert.AreEqual ({0}, *(scan + {1}), \"{1}\");", *(scan + p), p);
 640                                                 }
 641 #else
 642                                                 // sampling values from a well known bitmap
 643                                                 Assert.AreEqual (0, *(scan + 0), "0");
 644                                                 Assert.AreEqual (0, *(scan + 13), "13");
 645                                                 Assert.AreEqual (0, *(scan + 26), "26");
 646                                                 Assert.AreEqual (0, *(scan + 39), "39");
 647                                                 Assert.AreEqual (0, *(scan + 52), "52");
 648                                                 Assert.AreEqual (0, *(scan + 65), "65");
 649                                                 Assert.AreEqual (0, *(scan + 78), "78");
 650                                                 Assert.AreEqual (0, *(scan + 91), "91");
 651                                                 Assert.AreEqual (0, *(scan + 104), "104");
 652                                                 Assert.AreEqual (0, *(scan + 117), "117");
 653                                                 Assert.AreEqual (0, *(scan + 130), "130");
 654                                                 Assert.AreEqual (0, *(scan + 143), "143");
 655                                                 Assert.AreEqual (0, *(scan + 156), "156");
 656                                                 Assert.AreEqual (0, *(scan + 169), "169");
 657                                                 Assert.AreEqual (0, *(scan + 182), "182");
 658                                                 Assert.AreEqual (0, *(scan + 195), "195");
 659                                                 Assert.AreEqual (0, *(scan + 208), "208");
 660                                                 Assert.AreEqual (0, *(scan + 221), "221");
 661                                                 Assert.AreEqual (0, *(scan + 234), "234");
 662                                                 Assert.AreEqual (0, *(scan + 247), "247");
 663                                                 Assert.AreEqual (0, *(scan + 260), "260");
 664                                                 Assert.AreEqual (0, *(scan + 273), "273");
 665                                                 Assert.AreEqual (0, *(scan + 286), "286");
 666                                                 Assert.AreEqual (255, *(scan + 299), "299");
 667                                                 Assert.AreEqual (255, *(scan + 312), "312");
 668                                                 Assert.AreEqual (255, *(scan + 325), "325");
 669                                                 Assert.AreEqual (255, *(scan + 338), "338");
 670                                                 Assert.AreEqual (255, *(scan + 351), "351");
 671                                                 Assert.AreEqual (255, *(scan + 364), "364");
 672                                                 Assert.AreEqual (255, *(scan + 377), "377");
 673                                                 Assert.AreEqual (255, *(scan + 390), "390");
 674                                                 Assert.AreEqual (255, *(scan + 403), "403");
 675                                                 Assert.AreEqual (255, *(scan + 416), "416");
 676                                                 Assert.AreEqual (0, *(scan + 429), "429");
 677                                                 Assert.AreEqual (255, *(scan + 442), "442");
 678                                                 Assert.AreEqual (255, *(scan + 455), "455");
 679                                                 Assert.AreEqual (255, *(scan + 468), "468");
 680                                                 Assert.AreEqual (255, *(scan + 481), "481");
 681                                                 Assert.AreEqual (255, *(scan + 494), "494");
 682                                                 Assert.AreEqual (255, *(scan + 507), "507");
 683                                                 Assert.AreEqual (255, *(scan + 520), "520");
 684                                                 Assert.AreEqual (255, *(scan + 533), "533");
 685                                                 Assert.AreEqual (255, *(scan + 546), "546");
 686                                                 Assert.AreEqual (255, *(scan + 559), "559");
 687                                                 Assert.AreEqual (0, *(scan + 572), "572");
 688                                                 Assert.AreEqual (255, *(scan + 585), "585");
 689                                                 Assert.AreEqual (0, *(scan + 598), "598");
 690                                                 Assert.AreEqual (0, *(scan + 611), "611");
 691                                                 Assert.AreEqual (0, *(scan + 624), "624");
 692                                                 Assert.AreEqual (0, *(scan + 637), "637");
 693                                                 Assert.AreEqual (0, *(scan + 650), "650");
 694                                                 Assert.AreEqual (0, *(scan + 663), "663");
 695                                                 Assert.AreEqual (0, *(scan + 676), "676");
 696                                                 Assert.AreEqual (0, *(scan + 689), "689");
 697                                                 Assert.AreEqual (0, *(scan + 702), "702");
 698                                                 Assert.AreEqual (0, *(scan + 715), "715");
 699                                                 Assert.AreEqual (255, *(scan + 728), "728");
 700                                                 Assert.AreEqual (0, *(scan + 741), "741");
 701                                                 Assert.AreEqual (0, *(scan + 754), "754");
 702                                                 Assert.AreEqual (0, *(scan + 767), "767");
 703                                                 Assert.AreEqual (0, *(scan + 780), "780");
 704                                                 Assert.AreEqual (0, *(scan + 793), "793");
 705                                                 Assert.AreEqual (0, *(scan + 806), "806");
 706                                                 Assert.AreEqual (0, *(scan + 819), "819");
 707                                                 Assert.AreEqual (0, *(scan + 832), "832");
 708                                                 Assert.AreEqual (0, *(scan + 845), "845");
 709                                                 Assert.AreEqual (0, *(scan + 858), "858");
 710                                                 Assert.AreEqual (255, *(scan + 871), "871");
 711                                                 Assert.AreEqual (0, *(scan + 884), "884");
 712                                                 Assert.AreEqual (0, *(scan + 897), "897");
 713                                                 Assert.AreEqual (0, *(scan + 910), "910");
 714                                                 Assert.AreEqual (0, *(scan + 923), "923");
 715                                                 Assert.AreEqual (0, *(scan + 936), "936");
 716 #endif
 717                                         }
 718                                 }
 719                                 finally {
 720                                         bmp.UnlockBits (data);
 721                                 }
 722                         }
 723                 }
 724
 725                 // 64x64x256 only has a 64x64 size available
 726                 [Test]
 727                 public void Bitmap64Features ()
 728                 {
 729                         string sInFile = getInFile ("bitmaps/64x64x256.ico");
 730                         using (Bitmap bmp = new Bitmap (sInFile)) {
 731                                 GraphicsUnit unit = GraphicsUnit.World;
 732                                 RectangleF rect = bmp.GetBounds (ref unit);
 733
 734                                 Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.Icon), "Icon");
 735                                 Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
 736                                 Assert.AreEqual (73746, bmp.Flags, "bmp.Flags");
 737                                 Assert.AreEqual (256, bmp.Palette.Entries.Length, "Palette");
 738                                 Assert.AreEqual (1, bmp.FrameDimensionsList.Length, "FrameDimensionsList");
 739                                 Assert.AreEqual (0, bmp.PropertyIdList.Length, "PropertyIdList");
 740                                 Assert.AreEqual (0, bmp.PropertyItems.Length, "PropertyItems");
 741 #if NET_2_0
 742                                 Assert.IsNull (bmp.Tag, "Tag");
 743 #endif
 744                                 Assert.AreEqual (96.0f, bmp.HorizontalResolution, "HorizontalResolution");
 745                                 Assert.AreEqual (96.0f, bmp.VerticalResolution, "VerticalResolution");
 746                                 Assert.AreEqual (64, bmp.Width, "bmp.Width");
 747                                 Assert.AreEqual (64, bmp.Height, "bmp.Height");
 748
 749                                 Assert.AreEqual (0, rect.X, "rect.X");
 750                                 Assert.AreEqual (0, rect.Y, "rect.Y");
 751                                 Assert.AreEqual (64, rect.Width, "rect.Width");
 752                                 Assert.AreEqual (64, rect.Height, "rect.Height");
 753
 754                                 Assert.AreEqual (64, bmp.Size.Width, "bmp.Size.Width");
 755                                 Assert.AreEqual (64, bmp.Size.Height, "bmp.Size.Height");
 756                         }
 757                 }
 758
 759                 [Test]
 760                 public void Bitmap64Pixels ()
 761                 {
 762                         string sInFile = getInFile ("bitmaps/64x64x256.ico");
 763                         using (Bitmap bmp = new Bitmap (sInFile)) {
 764 #if false
 765                                 for (int x = 0; x < bmp.Width; x += 4) {
 766                                         for (int y = 0; y < bmp.Height; y += 4)
 767                                                 Console.WriteLine ("\t\t\t\tAssert.AreEqual ({0}, bmp.GetPixel ({1}, {2}).ToArgb (), \"{1},{2}\");", bmp.GetPixel (x, y).ToArgb (), x, y);
 768                                 }
 769 #else
 770                                 // sampling values from a well known bitmap
 771                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 0).ToArgb (), "0,0");
 772                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 4).ToArgb (), "0,4");
 773                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 8).ToArgb (), "0,8");
 774                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 12).ToArgb (), "0,12");
 775                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 16).ToArgb (), "0,16");
 776                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 20).ToArgb (), "0,20");
 777                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 24).ToArgb (), "0,24");
 778                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 28).ToArgb (), "0,28");
 779                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 32).ToArgb (), "0,32");
 780                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 36).ToArgb (), "0,36");
 781                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 40).ToArgb (), "0,40");
 782                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 44).ToArgb (), "0,44");
 783                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 48).ToArgb (), "0,48");
 784                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 52).ToArgb (), "0,52");
 785                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 56).ToArgb (), "0,56");
 786                                 Assert.AreEqual (-65383, bmp.GetPixel (0, 60).ToArgb (), "0,60");
 787                                 Assert.AreEqual (-65383, bmp.GetPixel (4, 0).ToArgb (), "4,0");
 788                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 4).ToArgb (), "4,4");
 789                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 8).ToArgb (), "4,8");
 790                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 12).ToArgb (), "4,12");
 791                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 16).ToArgb (), "4,16");
 792                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 20).ToArgb (), "4,20");
 793                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 24).ToArgb (), "4,24");
 794                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 28).ToArgb (), "4,28");
 795                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 32).ToArgb (), "4,32");
 796                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 36).ToArgb (), "4,36");
 797                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 40).ToArgb (), "4,40");
 798                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 44).ToArgb (), "4,44");
 799                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 48).ToArgb (), "4,48");
 800                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 52).ToArgb (), "4,52");
 801                                 Assert.AreEqual (-10079335, bmp.GetPixel (4, 56).ToArgb (), "4,56");
 802                                 Assert.AreEqual (0, bmp.GetPixel (4, 60).ToArgb (), "4,60");
 803                                 Assert.AreEqual (-65383, bmp.GetPixel (8, 0).ToArgb (), "8,0");
 804                                 Assert.AreEqual (-10079335, bmp.GetPixel (8, 4).ToArgb (), "8,4");
 805                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 8).ToArgb (), "8,8");
 806                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 12).ToArgb (), "8,12");
 807                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 16).ToArgb (), "8,16");
 808                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 20).ToArgb (), "8,20");
 809                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 24).ToArgb (), "8,24");
 810                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 28).ToArgb (), "8,28");
 811                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 32).ToArgb (), "8,32");
 812                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 36).ToArgb (), "8,36");
 813                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 40).ToArgb (), "8,40");
 814                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 44).ToArgb (), "8,44");
 815                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 48).ToArgb (), "8,48");
 816                                 Assert.AreEqual (-3342490, bmp.GetPixel (8, 52).ToArgb (), "8,52");
 817                                 Assert.AreEqual (0, bmp.GetPixel (8, 56).ToArgb (), "8,56");
 818                                 Assert.AreEqual (0, bmp.GetPixel (8, 60).ToArgb (), "8,60");
 819                                 Assert.AreEqual (-65383, bmp.GetPixel (12, 0).ToArgb (), "12,0");
 820                                 Assert.AreEqual (-10079335, bmp.GetPixel (12, 4).ToArgb (), "12,4");
 821                                 Assert.AreEqual (-3342490, bmp.GetPixel (12, 8).ToArgb (), "12,8");
 822                                 Assert.AreEqual (-33664, bmp.GetPixel (12, 12).ToArgb (), "12,12");
 823                                 Assert.AreEqual (-33664, bmp.GetPixel (12, 16).ToArgb (), "12,16");
 824                                 Assert.AreEqual (-33664, bmp.GetPixel (12, 20).ToArgb (), "12,20");
 825                                 Assert.AreEqual (-33664, bmp.GetPixel (12, 24).ToArgb (), "12,24");
 826                                 Assert.AreEqual (-33664, bmp.GetPixel (12, 28).ToArgb (), "12,28");
 827                                 Assert.AreEqual (-33664, bmp.GetPixel (12, 32).ToArgb (), "12,32");
 828                                 Assert.AreEqual (-33664, bmp.GetPixel (12, 36).ToArgb (), "12,36");
 829                                 Assert.AreEqual (-33664, bmp.GetPixel (12, 40).ToArgb (), "12,40");
 830 #endif
 831                         }
 832                 }
 833
 834                 [Test]
 835                 public void Bitmat64Data ()
 836                 {
 837                         string sInFile = getInFile ("bitmaps/64x64x256.ico");
 838                         using (Bitmap bmp = new Bitmap (sInFile)) {
 839                                 BitmapData data = bmp.LockBits (new Rectangle (0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
 840                                 try {
 841                                         Assert.AreEqual (bmp.Height, data.Height, "Height");
 842                                         Assert.AreEqual (bmp.Width, data.Width, "Width");
 843                                         Assert.AreEqual (PixelFormat.Format24bppRgb, data.PixelFormat, "PixelFormat");
 844                                         int size = data.Height * data.Stride;
 845                                         unsafe {
 846                                                 byte* scan = (byte*) data.Scan0;
 847 #if false
 848                                                 // 97 is prime (so we're not affected by a recurring pattern)
 849                                                 for (int p = 0; p < size; p += 97) {
 850                                                         Console.WriteLine ("\t\t\t\t\t\tAssert.AreEqual ({0}, *(scan + {1}), \"{1}\");", *(scan + p), p);
 851                                                 }
 852 #else
 853                                                 // sampling values from a well known bitmap
 854                                                 Assert.AreEqual (153, *(scan + 0), "0");
 855                                                 Assert.AreEqual (0, *(scan + 97), "97");
 856                                                 Assert.AreEqual (255, *(scan + 194), "194");
 857                                                 Assert.AreEqual (0, *(scan + 291), "291");
 858                                                 Assert.AreEqual (0, *(scan + 388), "388");
 859                                                 Assert.AreEqual (204, *(scan + 485), "485");
 860                                                 Assert.AreEqual (204, *(scan + 582), "582");
 861                                                 Assert.AreEqual (0, *(scan + 679), "679");
 862                                                 Assert.AreEqual (204, *(scan + 776), "776");
 863                                                 Assert.AreEqual (153, *(scan + 873), "873");
 864                                                 Assert.AreEqual (0, *(scan + 970), "970");
 865                                                 Assert.AreEqual (0, *(scan + 1067), "1067");
 866                                                 Assert.AreEqual (153, *(scan + 1164), "1164");
 867                                                 Assert.AreEqual (153, *(scan + 1261), "1261");
 868                                                 Assert.AreEqual (102, *(scan + 1358), "1358");
 869                                                 Assert.AreEqual (0, *(scan + 1455), "1455");
 870                                                 Assert.AreEqual (0, *(scan + 1552), "1552");
 871                                                 Assert.AreEqual (204, *(scan + 1649), "1649");
 872                                                 Assert.AreEqual (153, *(scan + 1746), "1746");
 873                                                 Assert.AreEqual (0, *(scan + 1843), "1843");
 874                                                 Assert.AreEqual (0, *(scan + 1940), "1940");
 875                                                 Assert.AreEqual (51, *(scan + 2037), "2037");
 876                                                 Assert.AreEqual (0, *(scan + 2134), "2134");
 877                                                 Assert.AreEqual (0, *(scan + 2231), "2231");
 878                                                 Assert.AreEqual (102, *(scan + 2328), "2328");
 879                                                 Assert.AreEqual (124, *(scan + 2425), "2425");
 880                                                 Assert.AreEqual (204, *(scan + 2522), "2522");
 881                                                 Assert.AreEqual (0, *(scan + 2619), "2619");
 882                                                 Assert.AreEqual (0, *(scan + 2716), "2716");
 883                                                 Assert.AreEqual (204, *(scan + 2813), "2813");
 884                                                 Assert.AreEqual (51, *(scan + 2910), "2910");
 885                                                 Assert.AreEqual (0, *(scan + 3007), "3007");
 886                                                 Assert.AreEqual (255, *(scan + 3104), "3104");
 887                                                 Assert.AreEqual (0, *(scan + 3201), "3201");
 888                                                 Assert.AreEqual (0, *(scan + 3298), "3298");
 889                                                 Assert.AreEqual (0, *(scan + 3395), "3395");
 890                                                 Assert.AreEqual (128, *(scan + 3492), "3492");
 891                                                 Assert.AreEqual (0, *(scan + 3589), "3589");
 892                                                 Assert.AreEqual (255, *(scan + 3686), "3686");
 893                                                 Assert.AreEqual (128, *(scan + 3783), "3783");
 894                                                 Assert.AreEqual (0, *(scan + 3880), "3880");
 895                                                 Assert.AreEqual (128, *(scan + 3977), "3977");
 896                                                 Assert.AreEqual (0, *(scan + 4074), "4074");
 897                                                 Assert.AreEqual (0, *(scan + 4171), "4171");
 898                                                 Assert.AreEqual (204, *(scan + 4268), "4268");
 899                                                 Assert.AreEqual (0, *(scan + 4365), "4365");
 900                                                 Assert.AreEqual (0, *(scan + 4462), "4462");
 901                                                 Assert.AreEqual (102, *(scan + 4559), "4559");
 902                                                 Assert.AreEqual (0, *(scan + 4656), "4656");
 903                                                 Assert.AreEqual (0, *(scan + 4753), "4753");
 904                                                 Assert.AreEqual (102, *(scan + 4850), "4850");
 905                                                 Assert.AreEqual (0, *(scan + 4947), "4947");
 906                                                 Assert.AreEqual (0, *(scan + 5044), "5044");
 907                                                 Assert.AreEqual (204, *(scan + 5141), "5141");
 908                                                 Assert.AreEqual (128, *(scan + 5238), "5238");
 909                                                 Assert.AreEqual (0, *(scan + 5335), "5335");
 910                                                 Assert.AreEqual (128, *(scan + 5432), "5432");
 911                                                 Assert.AreEqual (128, *(scan + 5529), "5529");
 912                                                 Assert.AreEqual (0, *(scan + 5626), "5626");
 913                                                 Assert.AreEqual (255, *(scan + 5723), "5723");
 914                                                 Assert.AreEqual (153, *(scan + 5820), "5820");
 915                                                 Assert.AreEqual (0, *(scan + 5917), "5917");
 916                                                 Assert.AreEqual (0, *(scan + 6014), "6014");
 917                                                 Assert.AreEqual (51, *(scan + 6111), "6111");
 918                                                 Assert.AreEqual (0, *(scan + 6208), "6208");
 919                                                 Assert.AreEqual (255, *(scan + 6305), "6305");
 920                                                 Assert.AreEqual (153, *(scan + 6402), "6402");
 921                                                 Assert.AreEqual (0, *(scan + 6499), "6499");
 922                                                 Assert.AreEqual (153, *(scan + 6596), "6596");
 923                                                 Assert.AreEqual (102, *(scan + 6693), "6693");
 924                                                 Assert.AreEqual (0, *(scan + 6790), "6790");
 925                                                 Assert.AreEqual (204, *(scan + 6887), "6887");
 926                                                 Assert.AreEqual (153, *(scan + 6984), "6984");
 927                                                 Assert.AreEqual (0, *(scan + 7081), "7081");
 928                                                 Assert.AreEqual (204, *(scan + 7178), "7178");
 929                                                 Assert.AreEqual (153, *(scan + 7275), "7275");
 930                                                 Assert.AreEqual (0, *(scan + 7372), "7372");
 931                                                 Assert.AreEqual (0, *(scan + 7469), "7469");
 932                                                 Assert.AreEqual (153, *(scan + 7566), "7566");
 933                                                 Assert.AreEqual (0, *(scan + 7663), "7663");
 934                                                 Assert.AreEqual (0, *(scan + 7760), "7760");
 935                                                 Assert.AreEqual (153, *(scan + 7857), "7857");
 936                                                 Assert.AreEqual (102, *(scan + 7954), "7954");
 937                                                 Assert.AreEqual (102, *(scan + 8051), "8051");
 938                                                 Assert.AreEqual (0, *(scan + 8148), "8148");
 939                                                 Assert.AreEqual (0, *(scan + 8245), "8245");
 940                                                 Assert.AreEqual (0, *(scan + 8342), "8342");
 941                                                 Assert.AreEqual (204, *(scan + 8439), "8439");
 942                                                 Assert.AreEqual (0, *(scan + 8536), "8536");
 943                                                 Assert.AreEqual (204, *(scan + 8633), "8633");
 944                                                 Assert.AreEqual (128, *(scan + 8730), "8730");
 945                                                 Assert.AreEqual (0, *(scan + 8827), "8827");
 946                                                 Assert.AreEqual (0, *(scan + 8924), "8924");
 947                                                 Assert.AreEqual (153, *(scan + 9021), "9021");
 948                                                 Assert.AreEqual (153, *(scan + 9118), "9118");
 949                                                 Assert.AreEqual (255, *(scan + 9215), "9215");
 950                                                 Assert.AreEqual (0, *(scan + 9312), "9312");
 951                                                 Assert.AreEqual (0, *(scan + 9409), "9409");
 952                                                 Assert.AreEqual (204, *(scan + 9506), "9506");
 953                                                 Assert.AreEqual (0, *(scan + 9603), "9603");
 954                                                 Assert.AreEqual (0, *(scan + 9700), "9700");
 955                                                 Assert.AreEqual (0, *(scan + 9797), "9797");
 956                                                 Assert.AreEqual (128, *(scan + 9894), "9894");
 957                                                 Assert.AreEqual (0, *(scan + 9991), "9991");
 958                                                 Assert.AreEqual (0, *(scan + 10088), "10088");
 959                                                 Assert.AreEqual (0, *(scan + 10185), "10185");
 960                                                 Assert.AreEqual (102, *(scan + 10282), "10282");
 961                                                 Assert.AreEqual (0, *(scan + 10379), "10379");
 962                                                 Assert.AreEqual (0, *(scan + 10476), "10476");
 963                                                 Assert.AreEqual (51, *(scan + 10573), "10573");
 964                                                 Assert.AreEqual (204, *(scan + 10670), "10670");
 965                                                 Assert.AreEqual (0, *(scan + 10767), "10767");
 966                                                 Assert.AreEqual (0, *(scan + 10864), "10864");
 967                                                 Assert.AreEqual (0, *(scan + 10961), "10961");
 968                                                 Assert.AreEqual (153, *(scan + 11058), "11058");
 969                                                 Assert.AreEqual (0, *(scan + 11155), "11155");
 970                                                 Assert.AreEqual (0, *(scan + 11252), "11252");
 971                                                 Assert.AreEqual (153, *(scan + 11349), "11349");
 972                                                 Assert.AreEqual (51, *(scan + 11446), "11446");
 973                                                 Assert.AreEqual (0, *(scan + 11543), "11543");
 974                                                 Assert.AreEqual (0, *(scan + 11640), "11640");
 975                                                 Assert.AreEqual (0, *(scan + 11737), "11737");
 976                                                 Assert.AreEqual (204, *(scan + 11834), "11834");
 977                                                 Assert.AreEqual (0, *(scan + 11931), "11931");
 978                                                 Assert.AreEqual (0, *(scan + 12028), "12028");
 979                                                 Assert.AreEqual (255, *(scan + 12125), "12125");
 980                                                 Assert.AreEqual (153, *(scan + 12222), "12222");
 981 #endif
 982                                         }
 983                                 }
 984                                 finally {
 985                                         bmp.UnlockBits (data);
 986                                 }
 987                         }
 988                 }
 989
 990                 // 96x96x256.ico only has a 96x96 size available
 991                 [Test]
 992                 public void Bitmap96Features ()
 993                 {
 994                         string sInFile = getInFile ("bitmaps/96x96x256.ico");
 995                         using (Bitmap bmp = new Bitmap (sInFile)) {
 996                                 GraphicsUnit unit = GraphicsUnit.World;
 997                                 RectangleF rect = bmp.GetBounds (ref unit);
 998
 999                                 Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.Icon), "Icon");
1000                                 Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
1001                                 Assert.AreEqual (73746, bmp.Flags, "bmp.Flags");
1002                                 Assert.AreEqual (256, bmp.Palette.Entries.Length, "Palette");
1003                                 Assert.AreEqual (1, bmp.FrameDimensionsList.Length, "FrameDimensionsList");
1004                                 Assert.AreEqual (0, bmp.PropertyIdList.Length, "PropertyIdList");
1005                                 Assert.AreEqual (0, bmp.PropertyItems.Length, "PropertyItems");
1006 #if NET_2_0
1007                                 Assert.IsNull (bmp.Tag, "Tag");
1008 #endif
1009                                 Assert.AreEqual (96.0f, bmp.HorizontalResolution, "HorizontalResolution");
1010                                 Assert.AreEqual (96.0f, bmp.VerticalResolution, "VerticalResolution");
1011                                 Assert.AreEqual (96, bmp.Width, "bmp.Width");
1012                                 Assert.AreEqual (96, bmp.Height, "bmp.Height");
1013
1014                                 Assert.AreEqual (0, rect.X, "rect.X");
1015                                 Assert.AreEqual (0, rect.Y, "rect.Y");
1016                                 Assert.AreEqual (96, rect.Width, "rect.Width");
1017                                 Assert.AreEqual (96, rect.Height, "rect.Height");
1018
1019                                 Assert.AreEqual (96, bmp.Size.Width, "bmp.Size.Width");
1020                                 Assert.AreEqual (96, bmp.Size.Height, "bmp.Size.Height");
1021                         }
1022                 }
1023
1024                 [Test]
1025                 public void Bitmap96Pixels ()
1026                 {
1027                         string sInFile = getInFile ("bitmaps/96x96x256.ico");
1028                         using (Bitmap bmp = new Bitmap (sInFile)) {
1029 #if false
1030                                 for (int x = 0; x < bmp.Width; x += 4) {
1031                                         for (int y = 0; y < bmp.Height; y += 4)
1032                                                 Console.WriteLine ("\t\t\t\tAssert.AreEqual ({0}, bmp.GetPixel ({1}, {2}).ToArgb (), \"{1},{2}\");", bmp.GetPixel (x, y).ToArgb (), x, y);
1033                                 }
1034 #else
1035                                 // sampling values from a well known bitmap
1036                                 Assert.AreEqual (0, bmp.GetPixel (0, 0).ToArgb (), "0,0");
1037                                 Assert.AreEqual (0, bmp.GetPixel (0, 4).ToArgb (), "0,4");
1038                                 Assert.AreEqual (0, bmp.GetPixel (0, 8).ToArgb (), "0,8");
1039                                 Assert.AreEqual (0, bmp.GetPixel (0, 12).ToArgb (), "0,12");
1040                                 Assert.AreEqual (0, bmp.GetPixel (0, 16).ToArgb (), "0,16");
1041                                 Assert.AreEqual (0, bmp.GetPixel (0, 20).ToArgb (), "0,20");
1042                                 Assert.AreEqual (0, bmp.GetPixel (0, 24).ToArgb (), "0,24");
1043                                 Assert.AreEqual (0, bmp.GetPixel (0, 28).ToArgb (), "0,28");
1044                                 Assert.AreEqual (0, bmp.GetPixel (0, 32).ToArgb (), "0,32");
1045                                 Assert.AreEqual (0, bmp.GetPixel (0, 36).ToArgb (), "0,36");
1046                                 Assert.AreEqual (0, bmp.GetPixel (0, 40).ToArgb (), "0,40");
1047                                 Assert.AreEqual (0, bmp.GetPixel (0, 44).ToArgb (), "0,44");
1048                                 Assert.AreEqual (0, bmp.GetPixel (0, 48).ToArgb (), "0,48");
1049                                 Assert.AreEqual (0, bmp.GetPixel (0, 52).ToArgb (), "0,52");
1050                                 Assert.AreEqual (0, bmp.GetPixel (0, 56).ToArgb (), "0,56");
1051                                 Assert.AreEqual (0, bmp.GetPixel (0, 60).ToArgb (), "0,60");
1052                                 Assert.AreEqual (0, bmp.GetPixel (0, 64).ToArgb (), "0,64");
1053                                 Assert.AreEqual (-14935012, bmp.GetPixel (0, 68).ToArgb (), "0,68");
1054                                 Assert.AreEqual (0, bmp.GetPixel (0, 72).ToArgb (), "0,72");
1055                                 Assert.AreEqual (0, bmp.GetPixel (0, 76).ToArgb (), "0,76");
1056                                 Assert.AreEqual (0, bmp.GetPixel (0, 80).ToArgb (), "0,80");
1057                                 Assert.AreEqual (0, bmp.GetPixel (0, 84).ToArgb (), "0,84");
1058                                 Assert.AreEqual (0, bmp.GetPixel (0, 88).ToArgb (), "0,88");
1059                                 Assert.AreEqual (0, bmp.GetPixel (0, 92).ToArgb (), "0,92");
1060                                 Assert.AreEqual (0, bmp.GetPixel (4, 0).ToArgb (), "4,0");
1061                                 Assert.AreEqual (0, bmp.GetPixel (4, 4).ToArgb (), "4,4");
1062                                 Assert.AreEqual (-14935012, bmp.GetPixel (4, 8).ToArgb (), "4,8");
1063                                 Assert.AreEqual (-3407872, bmp.GetPixel (4, 12).ToArgb (), "4,12");
1064                                 Assert.AreEqual (-3407872, bmp.GetPixel (4, 16).ToArgb (), "4,16");
1065                                 Assert.AreEqual (-14935012, bmp.GetPixel (4, 20).ToArgb (), "4,20");
1066                                 Assert.AreEqual (0, bmp.GetPixel (4, 24).ToArgb (), "4,24");
1067                                 Assert.AreEqual (0, bmp.GetPixel (4, 28).ToArgb (), "4,28");
1068                                 Assert.AreEqual (0, bmp.GetPixel (4, 32).ToArgb (), "4,32");
1069                                 Assert.AreEqual (0, bmp.GetPixel (4, 36).ToArgb (), "4,36");
1070                                 Assert.AreEqual (-3368602, bmp.GetPixel (4, 40).ToArgb (), "4,40");
1071                                 Assert.AreEqual (-3368602, bmp.GetPixel (4, 44).ToArgb (), "4,44");
1072                                 Assert.AreEqual (-3368602, bmp.GetPixel (4, 48).ToArgb (), "4,48");
1073                                 Assert.AreEqual (-3368602, bmp.GetPixel (4, 52).ToArgb (), "4,52");
1074                                 Assert.AreEqual (0, bmp.GetPixel (4, 56).ToArgb (), "4,56");
1075                                 Assert.AreEqual (0, bmp.GetPixel (4, 60).ToArgb (), "4,60");
1076                                 Assert.AreEqual (-3342541, bmp.GetPixel (4, 64).ToArgb (), "4,64");
1077                                 Assert.AreEqual (-3342541, bmp.GetPixel (4, 68).ToArgb (), "4,68");
1078                                 Assert.AreEqual (-3342541, bmp.GetPixel (4, 72).ToArgb (), "4,72");
1079                                 Assert.AreEqual (0, bmp.GetPixel (4, 76).ToArgb (), "4,76");
1080                                 Assert.AreEqual (0, bmp.GetPixel (4, 80).ToArgb (), "4,80");
1081                                 Assert.AreEqual (-26317, bmp.GetPixel (4, 84).ToArgb (), "4,84");
1082                                 Assert.AreEqual (-26317, bmp.GetPixel (4, 88).ToArgb (), "4,88");
1083                                 Assert.AreEqual (-26317, bmp.GetPixel (4, 92).ToArgb (), "4,92");
1084                                 Assert.AreEqual (0, bmp.GetPixel (8, 0).ToArgb (), "8,0");
1085                                 Assert.AreEqual (-14935012, bmp.GetPixel (8, 4).ToArgb (), "8,4");
1086                                 Assert.AreEqual (-3407872, bmp.GetPixel (8, 8).ToArgb (), "8,8");
1087                                 Assert.AreEqual (-3407872, bmp.GetPixel (8, 12).ToArgb (), "8,12");
1088                                 Assert.AreEqual (-3407872, bmp.GetPixel (8, 16).ToArgb (), "8,16");
1089                                 Assert.AreEqual (-3407872, bmp.GetPixel (8, 20).ToArgb (), "8,20");
1090                                 Assert.AreEqual (-14935012, bmp.GetPixel (8, 24).ToArgb (), "8,24");
1091                                 Assert.AreEqual (0, bmp.GetPixel (8, 28).ToArgb (), "8,28");
1092                                 Assert.AreEqual (0, bmp.GetPixel (8, 32).ToArgb (), "8,32");
1093                                 Assert.AreEqual (-3368602, bmp.GetPixel (8, 36).ToArgb (), "8,36");
1094                                 Assert.AreEqual (-3368602, bmp.GetPixel (8, 40).ToArgb (), "8,40");
1095                                 Assert.AreEqual (-3368602, bmp.GetPixel (8, 44).ToArgb (), "8,44");
1096                                 Assert.AreEqual (-3368602, bmp.GetPixel (8, 48).ToArgb (), "8,48");
1097                                 Assert.AreEqual (-3368602, bmp.GetPixel (8, 52).ToArgb (), "8,52");
1098                                 Assert.AreEqual (-3368602, bmp.GetPixel (8, 56).ToArgb (), "8,56");
1099                                 Assert.AreEqual (0, bmp.GetPixel (8, 60).ToArgb (), "8,60");
1100                                 Assert.AreEqual (-3342541, bmp.GetPixel (8, 64).ToArgb (), "8,64");
1101                                 Assert.AreEqual (-3342541, bmp.GetPixel (8, 68).ToArgb (), "8,68");
1102                                 Assert.AreEqual (-3342541, bmp.GetPixel (8, 72).ToArgb (), "8,72");
1103                                 Assert.AreEqual (0, bmp.GetPixel (8, 76).ToArgb (), "8,76");
1104                                 Assert.AreEqual (0, bmp.GetPixel (8, 80).ToArgb (), "8,80");
1105                                 Assert.AreEqual (-26317, bmp.GetPixel (8, 84).ToArgb (), "8,84");
1106                                 Assert.AreEqual (-26317, bmp.GetPixel (8, 88).ToArgb (), "8,88");
1107                                 Assert.AreEqual (-26317, bmp.GetPixel (8, 92).ToArgb (), "8,92");
1108                                 Assert.AreEqual (0, bmp.GetPixel (12, 0).ToArgb (), "12,0");
1109                                 Assert.AreEqual (-3407872, bmp.GetPixel (12, 4).ToArgb (), "12,4");
1110                                 Assert.AreEqual (-3407872, bmp.GetPixel (12, 8).ToArgb (), "12,8");
1111                                 Assert.AreEqual (-3407872, bmp.GetPixel (12, 12).ToArgb (), "12,12");
1112                                 Assert.AreEqual (-3407872, bmp.GetPixel (12, 16).ToArgb (), "12,16");
1113                                 Assert.AreEqual (-3407872, bmp.GetPixel (12, 20).ToArgb (), "12,20");
1114                                 Assert.AreEqual (-3407872, bmp.GetPixel (12, 24).ToArgb (), "12,24");
1115                                 Assert.AreEqual (0, bmp.GetPixel (12, 28).ToArgb (), "12,28");
1116                                 Assert.AreEqual (-3368602, bmp.GetPixel (12, 32).ToArgb (), "12,32");
1117                                 Assert.AreEqual (-3368602, bmp.GetPixel (12, 36).ToArgb (), "12,36");
1118                                 Assert.AreEqual (-3368602, bmp.GetPixel (12, 40).ToArgb (), "12,40");
1119                                 Assert.AreEqual (-3368602, bmp.GetPixel (12, 44).ToArgb (), "12,44");
1120                                 Assert.AreEqual (-3368602, bmp.GetPixel (12, 48).ToArgb (), "12,48");
1121                                 Assert.AreEqual (-3368602, bmp.GetPixel (12, 52).ToArgb (), "12,52");
1122                                 Assert.AreEqual (-3368602, bmp.GetPixel (12, 56).ToArgb (), "12,56");
1123                                 Assert.AreEqual (-3368602, bmp.GetPixel (12, 60).ToArgb (), "12,60");
1124                                 Assert.AreEqual (-3342541, bmp.GetPixel (12, 64).ToArgb (), "12,64");
1125                                 Assert.AreEqual (-3342541, bmp.GetPixel (12, 68).ToArgb (), "12,68");
1126                                 Assert.AreEqual (-14935012, bmp.GetPixel (12, 72).ToArgb (), "12,72");
1127                                 Assert.AreEqual (0, bmp.GetPixel (12, 76).ToArgb (), "12,76");
1128                                 Assert.AreEqual (0, bmp.GetPixel (12, 80).ToArgb (), "12,80");
1129                                 Assert.AreEqual (-26317, bmp.GetPixel (12, 84).ToArgb (), "12,84");
1130                                 Assert.AreEqual (-26317, bmp.GetPixel (12, 88).ToArgb (), "12,88");
1131                                 Assert.AreEqual (-26317, bmp.GetPixel (12, 92).ToArgb (), "12,92");
1132                                 Assert.AreEqual (0, bmp.GetPixel (16, 0).ToArgb (), "16,0");
1133                                 Assert.AreEqual (-3407872, bmp.GetPixel (16, 4).ToArgb (), "16,4");
1134                                 Assert.AreEqual (-3407872, bmp.GetPixel (16, 8).ToArgb (), "16,8");
1135                                 Assert.AreEqual (-3407872, bmp.GetPixel (16, 12).ToArgb (), "16,12");
1136                                 Assert.AreEqual (-3407872, bmp.GetPixel (16, 16).ToArgb (), "16,16");
1137                                 Assert.AreEqual (-3407872, bmp.GetPixel (16, 20).ToArgb (), "16,20");
1138                                 Assert.AreEqual (-3407872, bmp.GetPixel (16, 24).ToArgb (), "16,24");
1139                                 Assert.AreEqual (0, bmp.GetPixel (16, 28).ToArgb (), "16,28");
1140                                 Assert.AreEqual (-3368602, bmp.GetPixel (16, 32).ToArgb (), "16,32");
1141                                 Assert.AreEqual (-3368602, bmp.GetPixel (16, 36).ToArgb (), "16,36");
1142                                 Assert.AreEqual (-3368602, bmp.GetPixel (16, 40).ToArgb (), "16,40");
1143                                 Assert.AreEqual (-3368602, bmp.GetPixel (16, 44).ToArgb (), "16,44");
1144                                 Assert.AreEqual (-3368602, bmp.GetPixel (16, 48).ToArgb (), "16,48");
1145                                 Assert.AreEqual (-3368602, bmp.GetPixel (16, 52).ToArgb (), "16,52");
1146                                 Assert.AreEqual (-3368602, bmp.GetPixel (16, 56).ToArgb (), "16,56");
1147                                 Assert.AreEqual (-3368602, bmp.GetPixel (16, 60).ToArgb (), "16,60");
1148                                 Assert.AreEqual (0, bmp.GetPixel (16, 64).ToArgb (), "16,64");
1149                                 Assert.AreEqual (0, bmp.GetPixel (16, 68).ToArgb (), "16,68");
1150                                 Assert.AreEqual (0, bmp.GetPixel (16, 72).ToArgb (), "16,72");
1151                                 Assert.AreEqual (0, bmp.GetPixel (16, 76).ToArgb (), "16,76");
1152                                 Assert.AreEqual (-14935012, bmp.GetPixel (16, 80).ToArgb (), "16,80");
1153                                 Assert.AreEqual (0, bmp.GetPixel (16, 84).ToArgb (), "16,84");
1154                                 Assert.AreEqual (-14935012, bmp.GetPixel (16, 88).ToArgb (), "16,88");
1155                                 Assert.AreEqual (0, bmp.GetPixel (16, 92).ToArgb (), "16,92");
1156                                 Assert.AreEqual (0, bmp.GetPixel (20, 0).ToArgb (), "20,0");
1157                                 Assert.AreEqual (-14935012, bmp.GetPixel (20, 4).ToArgb (), "20,4");
1158                                 Assert.AreEqual (-3407872, bmp.GetPixel (20, 8).ToArgb (), "20,8");
1159                                 Assert.AreEqual (-3407872, bmp.GetPixel (20, 12).ToArgb (), "20,12");
1160                                 Assert.AreEqual (-3407872, bmp.GetPixel (20, 16).ToArgb (), "20,16");
1161                                 Assert.AreEqual (-3407872, bmp.GetPixel (20, 20).ToArgb (), "20,20");
1162                                 Assert.AreEqual (-14935012, bmp.GetPixel (20, 24).ToArgb (), "20,24");
1163                                 Assert.AreEqual (0, bmp.GetPixel (20, 28).ToArgb (), "20,28");
1164                                 Assert.AreEqual (-3368602, bmp.GetPixel (20, 32).ToArgb (), "20,32");
1165                                 Assert.AreEqual (-3368602, bmp.GetPixel (20, 36).ToArgb (), "20,36");
1166                                 Assert.AreEqual (-3368602, bmp.GetPixel (20, 40).ToArgb (), "20,40");
1167                                 Assert.AreEqual (-3368602, bmp.GetPixel (20, 44).ToArgb (), "20,44");
1168                                 Assert.AreEqual (-3368602, bmp.GetPixel (20, 48).ToArgb (), "20,48");
1169                                 Assert.AreEqual (-3368602, bmp.GetPixel (20, 52).ToArgb (), "20,52");
1170                                 Assert.AreEqual (-3368602, bmp.GetPixel (20, 56).ToArgb (), "20,56");
1171                                 Assert.AreEqual (-3368602, bmp.GetPixel (20, 60).ToArgb (), "20,60");
1172                                 Assert.AreEqual (0, bmp.GetPixel (20, 64).ToArgb (), "20,64");
1173                                 Assert.AreEqual (0, bmp.GetPixel (20, 68).ToArgb (), "20,68");
1174                                 Assert.AreEqual (-13434829, bmp.GetPixel (20, 72).ToArgb (), "20,72");
1175                                 Assert.AreEqual (-13434829, bmp.GetPixel (20, 76).ToArgb (), "20,76");
1176                                 Assert.AreEqual (-13434829, bmp.GetPixel (20, 80).ToArgb (), "20,80");
1177                                 Assert.AreEqual (-13434829, bmp.GetPixel (20, 84).ToArgb (), "20,84");
1178                                 Assert.AreEqual (-13434829, bmp.GetPixel (20, 88).ToArgb (), "20,88");
1179                                 Assert.AreEqual (0, bmp.GetPixel (20, 92).ToArgb (), "20,92");
1180                                 Assert.AreEqual (0, bmp.GetPixel (24, 0).ToArgb (), "24,0");
1181                                 Assert.AreEqual (0, bmp.GetPixel (24, 4).ToArgb (), "24,4");
1182                                 Assert.AreEqual (-14935012, bmp.GetPixel (24, 8).ToArgb (), "24,8");
1183                                 Assert.AreEqual (-3407872, bmp.GetPixel (24, 12).ToArgb (), "24,12");
1184                                 Assert.AreEqual (-3407872, bmp.GetPixel (24, 16).ToArgb (), "24,16");
1185                                 Assert.AreEqual (-14935012, bmp.GetPixel (24, 20).ToArgb (), "24,20");
1186                                 Assert.AreEqual (0, bmp.GetPixel (24, 24).ToArgb (), "24,24");
1187                                 Assert.AreEqual (0, bmp.GetPixel (24, 28).ToArgb (), "24,28");
1188                                 Assert.AreEqual (-3368602, bmp.GetPixel (24, 32).ToArgb (), "24,32");
1189                                 Assert.AreEqual (-3368602, bmp.GetPixel (24, 36).ToArgb (), "24,36");
1190                                 Assert.AreEqual (-3368602, bmp.GetPixel (24, 40).ToArgb (), "24,40");
1191                                 Assert.AreEqual (-3368602, bmp.GetPixel (24, 44).ToArgb (), "24,44");
1192                                 Assert.AreEqual (-3368602, bmp.GetPixel (24, 48).ToArgb (), "24,48");
1193                                 Assert.AreEqual (-3368602, bmp.GetPixel (24, 52).ToArgb (), "24,52");
1194                                 Assert.AreEqual (-3368602, bmp.GetPixel (24, 56).ToArgb (), "24,56");
1195                                 Assert.AreEqual (-3368602, bmp.GetPixel (24, 60).ToArgb (), "24,60");
1196                                 Assert.AreEqual (0, bmp.GetPixel (24, 64).ToArgb (), "24,64");
1197                                 Assert.AreEqual (-13434829, bmp.GetPixel (24, 68).ToArgb (), "24,68");
1198                                 Assert.AreEqual (-13434829, bmp.GetPixel (24, 72).ToArgb (), "24,72");
1199                                 Assert.AreEqual (-13434829, bmp.GetPixel (24, 76).ToArgb (), "24,76");
1200                                 Assert.AreEqual (-13434829, bmp.GetPixel (24, 80).ToArgb (), "24,80");
1201                                 Assert.AreEqual (-13434829, bmp.GetPixel (24, 84).ToArgb (), "24,84");
1202                                 Assert.AreEqual (-13434829, bmp.GetPixel (24, 88).ToArgb (), "24,88");
1203                                 Assert.AreEqual (-14935012, bmp.GetPixel (24, 92).ToArgb (), "24,92");
1204                                 Assert.AreEqual (0, bmp.GetPixel (28, 0).ToArgb (), "28,0");
1205                                 Assert.AreEqual (0, bmp.GetPixel (28, 4).ToArgb (), "28,4");
1206                                 Assert.AreEqual (-14935012, bmp.GetPixel (28, 8).ToArgb (), "28,8");
1207                                 Assert.AreEqual (0, bmp.GetPixel (28, 12).ToArgb (), "28,12");
1208                                 Assert.AreEqual (0, bmp.GetPixel (28, 16).ToArgb (), "28,16");
1209                                 Assert.AreEqual (-14935012, bmp.GetPixel (28, 20).ToArgb (), "28,20");
1210                                 Assert.AreEqual (-16777012, bmp.GetPixel (28, 24).ToArgb (), "28,24");
1211                                 Assert.AreEqual (0, bmp.GetPixel (28, 28).ToArgb (), "28,28");
1212                                 Assert.AreEqual (-3368602, bmp.GetPixel (28, 32).ToArgb (), "28,32");
1213                                 Assert.AreEqual (-3368602, bmp.GetPixel (28, 36).ToArgb (), "28,36");
1214                                 Assert.AreEqual (-3368602, bmp.GetPixel (28, 40).ToArgb (), "28,40");
1215                                 Assert.AreEqual (-3368602, bmp.GetPixel (28, 44).ToArgb (), "28,44");
1216                                 Assert.AreEqual (-3368602, bmp.GetPixel (28, 48).ToArgb (), "28,48");
1217                                 Assert.AreEqual (-3368602, bmp.GetPixel (28, 52).ToArgb (), "28,52");
1218                                 Assert.AreEqual (-3368602, bmp.GetPixel (28, 56).ToArgb (), "28,56");
1219                                 Assert.AreEqual (-3368602, bmp.GetPixel (28, 60).ToArgb (), "28,60");
1220                                 Assert.AreEqual (0, bmp.GetPixel (28, 64).ToArgb (), "28,64");
1221                                 Assert.AreEqual (-13434829, bmp.GetPixel (28, 68).ToArgb (), "28,68");
1222                                 Assert.AreEqual (-13434829, bmp.GetPixel (28, 72).ToArgb (), "28,72");
1223                                 Assert.AreEqual (-13434829, bmp.GetPixel (28, 76).ToArgb (), "28,76");
1224                                 Assert.AreEqual (-13434829, bmp.GetPixel (28, 80).ToArgb (), "28,80");
1225                                 Assert.AreEqual (-13434829, bmp.GetPixel (28, 84).ToArgb (), "28,84");
1226                                 Assert.AreEqual (-13434829, bmp.GetPixel (28, 88).ToArgb (), "28,88");
1227                                 Assert.AreEqual (-13434829, bmp.GetPixel (28, 92).ToArgb (), "28,92");
1228                                 Assert.AreEqual (0, bmp.GetPixel (32, 0).ToArgb (), "32,0");
1229                                 Assert.AreEqual (-10027264, bmp.GetPixel (32, 4).ToArgb (), "32,4");
1230                                 Assert.AreEqual (-10027264, bmp.GetPixel (32, 8).ToArgb (), "32,8");
1231                                 Assert.AreEqual (-10027264, bmp.GetPixel (32, 12).ToArgb (), "32,12");
1232                                 Assert.AreEqual (-14935012, bmp.GetPixel (32, 16).ToArgb (), "32,16");
1233                                 Assert.AreEqual (-16777012, bmp.GetPixel (32, 20).ToArgb (), "32,20");
1234                                 Assert.AreEqual (-16777012, bmp.GetPixel (32, 24).ToArgb (), "32,24");
1235                                 Assert.AreEqual (-16777012, bmp.GetPixel (32, 28).ToArgb (), "32,28");
1236                                 Assert.AreEqual (0, bmp.GetPixel (32, 32).ToArgb (), "32,32");
1237                                 Assert.AreEqual (-3368602, bmp.GetPixel (32, 36).ToArgb (), "32,36");
1238                                 Assert.AreEqual (-3368602, bmp.GetPixel (32, 40).ToArgb (), "32,40");
1239                                 Assert.AreEqual (-3368602, bmp.GetPixel (32, 44).ToArgb (), "32,44");
1240                                 Assert.AreEqual (-3368602, bmp.GetPixel (32, 48).ToArgb (), "32,48");
1241                                 Assert.AreEqual (-3368602, bmp.GetPixel (32, 52).ToArgb (), "32,52");
1242                                 Assert.AreEqual (-3368602, bmp.GetPixel (32, 56).ToArgb (), "32,56");
1243                                 Assert.AreEqual (0, bmp.GetPixel (32, 60).ToArgb (), "32,60");
1244                                 Assert.AreEqual (0, bmp.GetPixel (32, 64).ToArgb (), "32,64");
1245                                 Assert.AreEqual (-13434829, bmp.GetPixel (32, 68).ToArgb (), "32,68");
1246                                 Assert.AreEqual (-13434829, bmp.GetPixel (32, 72).ToArgb (), "32,72");
1247                                 Assert.AreEqual (-13434829, bmp.GetPixel (32, 76).ToArgb (), "32,76");
1248                                 Assert.AreEqual (-13434829, bmp.GetPixel (32, 80).ToArgb (), "32,80");
1249                                 Assert.AreEqual (-13434829, bmp.GetPixel (32, 84).ToArgb (), "32,84");
1250                                 Assert.AreEqual (-13434829, bmp.GetPixel (32, 88).ToArgb (), "32,88");
1251                                 Assert.AreEqual (-13434829, bmp.GetPixel (32, 92).ToArgb (), "32,92");
1252                                 Assert.AreEqual (0, bmp.GetPixel (36, 0).ToArgb (), "36,0");
1253                                 Assert.AreEqual (-10027264, bmp.GetPixel (36, 4).ToArgb (), "36,4");
1254                                 Assert.AreEqual (-10027264, bmp.GetPixel (36, 8).ToArgb (), "36,8");
1255                                 Assert.AreEqual (-10027264, bmp.GetPixel (36, 12).ToArgb (), "36,12");
1256                                 Assert.AreEqual (-10027264, bmp.GetPixel (36, 16).ToArgb (), "36,16");
1257                                 Assert.AreEqual (-14935012, bmp.GetPixel (36, 20).ToArgb (), "36,20");
1258                                 Assert.AreEqual (-16777012, bmp.GetPixel (36, 24).ToArgb (), "36,24");
1259                                 Assert.AreEqual (0, bmp.GetPixel (36, 28).ToArgb (), "36,28");
1260                                 Assert.AreEqual (0, bmp.GetPixel (36, 32).ToArgb (), "36,32");
1261                                 Assert.AreEqual (0, bmp.GetPixel (36, 36).ToArgb (), "36,36");
1262                                 Assert.AreEqual (-3368602, bmp.GetPixel (36, 40).ToArgb (), "36,40");
1263                                 Assert.AreEqual (-3368602, bmp.GetPixel (36, 44).ToArgb (), "36,44");
1264                                 Assert.AreEqual (-3368602, bmp.GetPixel (36, 48).ToArgb (), "36,48");
1265                                 Assert.AreEqual (-3368602, bmp.GetPixel (36, 52).ToArgb (), "36,52");
1266                                 Assert.AreEqual (0, bmp.GetPixel (36, 56).ToArgb (), "36,56");
1267                                 Assert.AreEqual (0, bmp.GetPixel (36, 60).ToArgb (), "36,60");
1268                                 Assert.AreEqual (0, bmp.GetPixel (36, 64).ToArgb (), "36,64");
1269                                 Assert.AreEqual (-13434829, bmp.GetPixel (36, 68).ToArgb (), "36,68");
1270                                 Assert.AreEqual (-13434829, bmp.GetPixel (36, 72).ToArgb (), "36,72");
1271                                 Assert.AreEqual (-13434829, bmp.GetPixel (36, 76).ToArgb (), "36,76");
1272                                 Assert.AreEqual (-13434829, bmp.GetPixel (36, 80).ToArgb (), "36,80");
1273                                 Assert.AreEqual (-13434829, bmp.GetPixel (36, 84).ToArgb (), "36,84");
1274                                 Assert.AreEqual (-13434829, bmp.GetPixel (36, 88).ToArgb (), "36,88");
1275                                 Assert.AreEqual (-13434829, bmp.GetPixel (36, 92).ToArgb (), "36,92");
1276                                 Assert.AreEqual (0, bmp.GetPixel (40, 0).ToArgb (), "40,0");
1277                                 Assert.AreEqual (-10027264, bmp.GetPixel (40, 4).ToArgb (), "40,4");
1278                                 Assert.AreEqual (-10027264, bmp.GetPixel (40, 8).ToArgb (), "40,8");
1279                                 Assert.AreEqual (-10027264, bmp.GetPixel (40, 12).ToArgb (), "40,12");
1280                                 Assert.AreEqual (-14935012, bmp.GetPixel (40, 16).ToArgb (), "40,16");
1281                                 Assert.AreEqual (0, bmp.GetPixel (40, 20).ToArgb (), "40,20");
1282                                 Assert.AreEqual (0, bmp.GetPixel (40, 24).ToArgb (), "40,24");
1283                                 Assert.AreEqual (0, bmp.GetPixel (40, 28).ToArgb (), "40,28");
1284                                 Assert.AreEqual (-13408717, bmp.GetPixel (40, 32).ToArgb (), "40,32");
1285                                 Assert.AreEqual (-13408717, bmp.GetPixel (40, 36).ToArgb (), "40,36");
1286                                 Assert.AreEqual (0, bmp.GetPixel (40, 40).ToArgb (), "40,40");
1287                                 Assert.AreEqual (0, bmp.GetPixel (40, 44).ToArgb (), "40,44");
1288                                 Assert.AreEqual (-14935012, bmp.GetPixel (40, 48).ToArgb (), "40,48");
1289                                 Assert.AreEqual (0, bmp.GetPixel (40, 52).ToArgb (), "40,52");
1290                                 Assert.AreEqual (0, bmp.GetPixel (40, 56).ToArgb (), "40,56");
1291                                 Assert.AreEqual (-26317, bmp.GetPixel (40, 60).ToArgb (), "40,60");
1292                                 Assert.AreEqual (-26317, bmp.GetPixel (40, 64).ToArgb (), "40,64");
1293                                 Assert.AreEqual (-14935012, bmp.GetPixel (40, 68).ToArgb (), "40,68");
1294                                 Assert.AreEqual (-13434829, bmp.GetPixel (40, 72).ToArgb (), "40,72");
1295                                 Assert.AreEqual (-13434829, bmp.GetPixel (40, 76).ToArgb (), "40,76");
1296                                 Assert.AreEqual (-13434829, bmp.GetPixel (40, 80).ToArgb (), "40,80");
1297                                 Assert.AreEqual (-13434829, bmp.GetPixel (40, 84).ToArgb (), "40,84");
1298                                 Assert.AreEqual (-13434829, bmp.GetPixel (40, 88).ToArgb (), "40,88");
1299                                 Assert.AreEqual (0, bmp.GetPixel (40, 92).ToArgb (), "40,92");
1300                                 Assert.AreEqual (0, bmp.GetPixel (44, 0).ToArgb (), "44,0");
1301                                 Assert.AreEqual (0, bmp.GetPixel (44, 4).ToArgb (), "44,4");
1302                                 Assert.AreEqual (-14935012, bmp.GetPixel (44, 8).ToArgb (), "44,8");
1303                                 Assert.AreEqual (0, bmp.GetPixel (44, 12).ToArgb (), "44,12");
1304                                 Assert.AreEqual (0, bmp.GetPixel (44, 16).ToArgb (), "44,16");
1305                                 Assert.AreEqual (0, bmp.GetPixel (44, 20).ToArgb (), "44,20");
1306                                 Assert.AreEqual (0, bmp.GetPixel (44, 24).ToArgb (), "44,24");
1307                                 Assert.AreEqual (0, bmp.GetPixel (44, 28).ToArgb (), "44,28");
1308                                 Assert.AreEqual (-13408717, bmp.GetPixel (44, 32).ToArgb (), "44,32");
1309                                 Assert.AreEqual (-13408717, bmp.GetPixel (44, 36).ToArgb (), "44,36");
1310                                 Assert.AreEqual (0, bmp.GetPixel (44, 40).ToArgb (), "44,40");
1311                                 Assert.AreEqual (-13312, bmp.GetPixel (44, 44).ToArgb (), "44,44");
1312                                 Assert.AreEqual (-13312, bmp.GetPixel (44, 48).ToArgb (), "44,48");
1313                                 Assert.AreEqual (-13312, bmp.GetPixel (44, 52).ToArgb (), "44,52");
1314                                 Assert.AreEqual (-13312, bmp.GetPixel (44, 56).ToArgb (), "44,56");
1315                                 Assert.AreEqual (-14935012, bmp.GetPixel (44, 60).ToArgb (), "44,60");
1316                                 Assert.AreEqual (-14935012, bmp.GetPixel (44, 64).ToArgb (), "44,64");
1317                                 Assert.AreEqual (0, bmp.GetPixel (44, 68).ToArgb (), "44,68");
1318                                 Assert.AreEqual (-14935012, bmp.GetPixel (44, 72).ToArgb (), "44,72");
1319                                 Assert.AreEqual (-13434829, bmp.GetPixel (44, 76).ToArgb (), "44,76");
1320                                 Assert.AreEqual (-13434829, bmp.GetPixel (44, 80).ToArgb (), "44,80");
1321                                 Assert.AreEqual (-13434829, bmp.GetPixel (44, 84).ToArgb (), "44,84");
1322                                 Assert.AreEqual (-14935012, bmp.GetPixel (44, 88).ToArgb (), "44,88");
1323                                 Assert.AreEqual (0, bmp.GetPixel (44, 92).ToArgb (), "44,92");
1324                                 Assert.AreEqual (0, bmp.GetPixel (48, 0).ToArgb (), "48,0");
1325                                 Assert.AreEqual (0, bmp.GetPixel (48, 4).ToArgb (), "48,4");
1326                                 Assert.AreEqual (0, bmp.GetPixel (48, 8).ToArgb (), "48,8");
1327                                 Assert.AreEqual (0, bmp.GetPixel (48, 12).ToArgb (), "48,12");
1328                                 Assert.AreEqual (-52429, bmp.GetPixel (48, 16).ToArgb (), "48,16");
1329                                 Assert.AreEqual (-52429, bmp.GetPixel (48, 20).ToArgb (), "48,20");
1330                                 Assert.AreEqual (-52429, bmp.GetPixel (48, 24).ToArgb (), "48,24");
1331                                 Assert.AreEqual (-52429, bmp.GetPixel (48, 28).ToArgb (), "48,28");
1332                                 Assert.AreEqual (-14935012, bmp.GetPixel (48, 32).ToArgb (), "48,32");
1333                                 Assert.AreEqual (0, bmp.GetPixel (48, 36).ToArgb (), "48,36");
1334                                 Assert.AreEqual (-14935012, bmp.GetPixel (48, 40).ToArgb (), "48,40");
1335                                 Assert.AreEqual (-13312, bmp.GetPixel (48, 44).ToArgb (), "48,44");
1336                                 Assert.AreEqual (-13312, bmp.GetPixel (48, 48).ToArgb (), "48,48");
1337                                 Assert.AreEqual (-13312, bmp.GetPixel (48, 52).ToArgb (), "48,52");
1338                                 Assert.AreEqual (-13312, bmp.GetPixel (48, 56).ToArgb (), "48,56");
1339                                 Assert.AreEqual (0, bmp.GetPixel (48, 60).ToArgb (), "48,60");
1340                                 Assert.AreEqual (1842204, bmp.GetPixel (48, 64).ToArgb (), "48,64");
1341                                 Assert.AreEqual (-3355546, bmp.GetPixel (48, 68).ToArgb (), "48,68");
1342                                 Assert.AreEqual (-3355546, bmp.GetPixel (48, 72).ToArgb (), "48,72");
1343                                 Assert.AreEqual (0, bmp.GetPixel (48, 76).ToArgb (), "48,76");
1344                                 Assert.AreEqual (0, bmp.GetPixel (48, 80).ToArgb (), "48,80");
1345                                 Assert.AreEqual (0, bmp.GetPixel (48, 84).ToArgb (), "48,84");
1346                                 Assert.AreEqual (0, bmp.GetPixel (48, 88).ToArgb (), "48,88");
1347                                 Assert.AreEqual (0, bmp.GetPixel (48, 92).ToArgb (), "48,92");
1348                                 Assert.AreEqual (0, bmp.GetPixel (52, 0).ToArgb (), "52,0");
1349                                 Assert.AreEqual (0, bmp.GetPixel (52, 4).ToArgb (), "52,4");
1350                                 Assert.AreEqual (-14935012, bmp.GetPixel (52, 8).ToArgb (), "52,8");
1351                                 Assert.AreEqual (-52429, bmp.GetPixel (52, 12).ToArgb (), "52,12");
1352                                 Assert.AreEqual (-52429, bmp.GetPixel (52, 16).ToArgb (), "52,16");
1353                                 Assert.AreEqual (-52429, bmp.GetPixel (52, 20).ToArgb (), "52,20");
1354                                 Assert.AreEqual (-52429, bmp.GetPixel (52, 24).ToArgb (), "52,24");
1355                                 Assert.AreEqual (-52429, bmp.GetPixel (52, 28).ToArgb (), "52,28");
1356                                 Assert.AreEqual (-52429, bmp.GetPixel (52, 32).ToArgb (), "52,32");
1357                                 Assert.AreEqual (-52429, bmp.GetPixel (52, 36).ToArgb (), "52,36");
1358                                 Assert.AreEqual (-14935012, bmp.GetPixel (52, 40).ToArgb (), "52,40");
1359                                 Assert.AreEqual (-13312, bmp.GetPixel (52, 44).ToArgb (), "52,44");
1360                                 Assert.AreEqual (-13312, bmp.GetPixel (52, 48).ToArgb (), "52,48");
1361                                 Assert.AreEqual (-13312, bmp.GetPixel (52, 52).ToArgb (), "52,52");
1362                                 Assert.AreEqual (-13312, bmp.GetPixel (52, 56).ToArgb (), "52,56");
1363                                 Assert.AreEqual (0, bmp.GetPixel (52, 60).ToArgb (), "52,60");
1364                                 Assert.AreEqual (-3355546, bmp.GetPixel (52, 64).ToArgb (), "52,64");
1365                                 Assert.AreEqual (-3355546, bmp.GetPixel (52, 68).ToArgb (), "52,68");
1366                                 Assert.AreEqual (-3355546, bmp.GetPixel (52, 72).ToArgb (), "52,72");
1367                                 Assert.AreEqual (-3355546, bmp.GetPixel (52, 76).ToArgb (), "52,76");
1368                                 Assert.AreEqual (0, bmp.GetPixel (52, 80).ToArgb (), "52,80");
1369                                 Assert.AreEqual (-6737101, bmp.GetPixel (52, 84).ToArgb (), "52,84");
1370                                 Assert.AreEqual (-6737101, bmp.GetPixel (52, 88).ToArgb (), "52,88");
1371                                 Assert.AreEqual (-6737101, bmp.GetPixel (52, 92).ToArgb (), "52,92");
1372                                 Assert.AreEqual (0, bmp.GetPixel (56, 0).ToArgb (), "56,0");
1373                                 Assert.AreEqual (0, bmp.GetPixel (56, 4).ToArgb (), "56,4");
1374                                 Assert.AreEqual (-52429, bmp.GetPixel (56, 8).ToArgb (), "56,8");
1375                                 Assert.AreEqual (-52429, bmp.GetPixel (56, 12).ToArgb (), "56,12");
1376                                 Assert.AreEqual (-52429, bmp.GetPixel (56, 16).ToArgb (), "56,16");
1377                                 Assert.AreEqual (-52429, bmp.GetPixel (56, 20).ToArgb (), "56,20");
1378                                 Assert.AreEqual (-52429, bmp.GetPixel (56, 24).ToArgb (), "56,24");
1379                                 Assert.AreEqual (-52429, bmp.GetPixel (56, 28).ToArgb (), "56,28");
1380                                 Assert.AreEqual (-52429, bmp.GetPixel (56, 32).ToArgb (), "56,32");
1381                                 Assert.AreEqual (-52429, bmp.GetPixel (56, 36).ToArgb (), "56,36");
1382                                 Assert.AreEqual (-14935012, bmp.GetPixel (56, 40).ToArgb (), "56,40");
1383                                 Assert.AreEqual (-13312, bmp.GetPixel (56, 44).ToArgb (), "56,44");
1384                                 Assert.AreEqual (-13312, bmp.GetPixel (56, 48).ToArgb (), "56,48");
1385                                 Assert.AreEqual (-13312, bmp.GetPixel (56, 52).ToArgb (), "56,52");
1386                                 Assert.AreEqual (-13312, bmp.GetPixel (56, 56).ToArgb (), "56,56");
1387                                 Assert.AreEqual (0, bmp.GetPixel (56, 60).ToArgb (), "56,60");
1388                                 Assert.AreEqual (-3355546, bmp.GetPixel (56, 64).ToArgb (), "56,64");
1389                                 Assert.AreEqual (-3355546, bmp.GetPixel (56, 68).ToArgb (), "56,68");
1390                                 Assert.AreEqual (-3355546, bmp.GetPixel (56, 72).ToArgb (), "56,72");
1391                                 Assert.AreEqual (-3355546, bmp.GetPixel (56, 76).ToArgb (), "56,76");
1392                                 Assert.AreEqual (-6737101, bmp.GetPixel (56, 80).ToArgb (), "56,80");
1393                                 Assert.AreEqual (-6737101, bmp.GetPixel (56, 84).ToArgb (), "56,84");
1394                                 Assert.AreEqual (-6737101, bmp.GetPixel (56, 88).ToArgb (), "56,88");
1395                                 Assert.AreEqual (-6737101, bmp.GetPixel (56, 92).ToArgb (), "56,92");
1396                                 Assert.AreEqual (0, bmp.GetPixel (60, 0).ToArgb (), "60,0");
1397                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 4).ToArgb (), "60,4");
1398                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 8).ToArgb (), "60,8");
1399                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 12).ToArgb (), "60,12");
1400                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 16).ToArgb (), "60,16");
1401                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 20).ToArgb (), "60,20");
1402                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 24).ToArgb (), "60,24");
1403                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 28).ToArgb (), "60,28");
1404                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 32).ToArgb (), "60,32");
1405                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 36).ToArgb (), "60,36");
1406                                 Assert.AreEqual (-52429, bmp.GetPixel (60, 40).ToArgb (), "60,40");
1407                                 Assert.AreEqual (0, bmp.GetPixel (60, 44).ToArgb (), "60,44");
1408                                 Assert.AreEqual (-14935012, bmp.GetPixel (60, 48).ToArgb (), "60,48");
1409                                 Assert.AreEqual (0, bmp.GetPixel (60, 52).ToArgb (), "60,52");
1410                                 Assert.AreEqual (0, bmp.GetPixel (60, 56).ToArgb (), "60,56");
1411                                 Assert.AreEqual (0, bmp.GetPixel (60, 60).ToArgb (), "60,60");
1412                                 Assert.AreEqual (0, bmp.GetPixel (60, 64).ToArgb (), "60,64");
1413                                 Assert.AreEqual (-3355546, bmp.GetPixel (60, 68).ToArgb (), "60,68");
1414                                 Assert.AreEqual (-3355546, bmp.GetPixel (60, 72).ToArgb (), "60,72");
1415                                 Assert.AreEqual (0, bmp.GetPixel (60, 76).ToArgb (), "60,76");
1416                                 Assert.AreEqual (-6737101, bmp.GetPixel (60, 80).ToArgb (), "60,80");
1417                                 Assert.AreEqual (-6737101, bmp.GetPixel (60, 84).ToArgb (), "60,84");
1418                                 Assert.AreEqual (-6737101, bmp.GetPixel (60, 88).ToArgb (), "60,88");
1419                                 Assert.AreEqual (-6737101, bmp.GetPixel (60, 92).ToArgb (), "60,92");
1420                                 Assert.AreEqual (0, bmp.GetPixel (64, 0).ToArgb (), "64,0");
1421                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 4).ToArgb (), "64,4");
1422                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 8).ToArgb (), "64,8");
1423                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 12).ToArgb (), "64,12");
1424                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 16).ToArgb (), "64,16");
1425                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 20).ToArgb (), "64,20");
1426                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 24).ToArgb (), "64,24");
1427                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 28).ToArgb (), "64,28");
1428                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 32).ToArgb (), "64,32");
1429                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 36).ToArgb (), "64,36");
1430                                 Assert.AreEqual (-52429, bmp.GetPixel (64, 40).ToArgb (), "64,40");
1431                                 Assert.AreEqual (-14935012, bmp.GetPixel (64, 44).ToArgb (), "64,44");
1432                                 Assert.AreEqual (0, bmp.GetPixel (64, 48).ToArgb (), "64,48");
1433                                 Assert.AreEqual (0, bmp.GetPixel (64, 52).ToArgb (), "64,52");
1434                                 Assert.AreEqual (-6750157, bmp.GetPixel (64, 56).ToArgb (), "64,56");
1435                                 Assert.AreEqual (-6750157, bmp.GetPixel (64, 60).ToArgb (), "64,60");
1436                                 Assert.AreEqual (-6750157, bmp.GetPixel (64, 64).ToArgb (), "64,64");
1437                                 Assert.AreEqual (-14935012, bmp.GetPixel (64, 68).ToArgb (), "64,68");
1438                                 Assert.AreEqual (0, bmp.GetPixel (64, 72).ToArgb (), "64,72");
1439                                 Assert.AreEqual (0, bmp.GetPixel (64, 76).ToArgb (), "64,76");
1440                                 Assert.AreEqual (0, bmp.GetPixel (64, 80).ToArgb (), "64,80");
1441                                 Assert.AreEqual (-6737101, bmp.GetPixel (64, 84).ToArgb (), "64,84");
1442                                 Assert.AreEqual (-6737101, bmp.GetPixel (64, 88).ToArgb (), "64,88");
1443                                 Assert.AreEqual (-14935012, bmp.GetPixel (64, 92).ToArgb (), "64,92");
1444                                 Assert.AreEqual (-14935012, bmp.GetPixel (68, 0).ToArgb (), "68,0");
1445                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 4).ToArgb (), "68,4");
1446                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 8).ToArgb (), "68,8");
1447                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 12).ToArgb (), "68,12");
1448                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 16).ToArgb (), "68,16");
1449                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 20).ToArgb (), "68,20");
1450                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 24).ToArgb (), "68,24");
1451                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 28).ToArgb (), "68,28");
1452                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 32).ToArgb (), "68,32");
1453                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 36).ToArgb (), "68,36");
1454                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 40).ToArgb (), "68,40");
1455                                 Assert.AreEqual (-52429, bmp.GetPixel (68, 44).ToArgb (), "68,44");
1456                                 Assert.AreEqual (0, bmp.GetPixel (68, 48).ToArgb (), "68,48");
1457                                 Assert.AreEqual (-6750157, bmp.GetPixel (68, 52).ToArgb (), "68,52");
1458                                 Assert.AreEqual (-6750157, bmp.GetPixel (68, 56).ToArgb (), "68,56");
1459                                 Assert.AreEqual (-6750157, bmp.GetPixel (68, 60).ToArgb (), "68,60");
1460                                 Assert.AreEqual (-6750157, bmp.GetPixel (68, 64).ToArgb (), "68,64");
1461                                 Assert.AreEqual (-6750157, bmp.GetPixel (68, 68).ToArgb (), "68,68");
1462                                 Assert.AreEqual (-14935012, bmp.GetPixel (68, 72).ToArgb (), "68,72");
1463                                 Assert.AreEqual (-16751002, bmp.GetPixel (68, 76).ToArgb (), "68,76");
1464                                 Assert.AreEqual (-16751002, bmp.GetPixel (68, 80).ToArgb (), "68,80");
1465                                 Assert.AreEqual (0, bmp.GetPixel (68, 84).ToArgb (), "68,84");
1466                                 Assert.AreEqual (0, bmp.GetPixel (68, 88).ToArgb (), "68,88");
1467                                 Assert.AreEqual (-39373, bmp.GetPixel (68, 92).ToArgb (), "68,92");
1468                                 Assert.AreEqual (-14935012, bmp.GetPixel (72, 0).ToArgb (), "72,0");
1469                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 4).ToArgb (), "72,4");
1470                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 8).ToArgb (), "72,8");
1471                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 12).ToArgb (), "72,12");
1472                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 16).ToArgb (), "72,16");
1473                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 20).ToArgb (), "72,20");
1474                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 24).ToArgb (), "72,24");
1475                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 28).ToArgb (), "72,28");
1476                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 32).ToArgb (), "72,32");
1477                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 36).ToArgb (), "72,36");
1478                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 40).ToArgb (), "72,40");
1479                                 Assert.AreEqual (-52429, bmp.GetPixel (72, 44).ToArgb (), "72,44");
1480                                 Assert.AreEqual (-14935012, bmp.GetPixel (72, 48).ToArgb (), "72,48");
1481                                 Assert.AreEqual (-6750157, bmp.GetPixel (72, 52).ToArgb (), "72,52");
1482                                 Assert.AreEqual (-6750157, bmp.GetPixel (72, 56).ToArgb (), "72,56");
1483                                 Assert.AreEqual (-6750157, bmp.GetPixel (72, 60).ToArgb (), "72,60");
1484                                 Assert.AreEqual (-6750157, bmp.GetPixel (72, 64).ToArgb (), "72,64");
1485                                 Assert.AreEqual (-6750157, bmp.GetPixel (72, 68).ToArgb (), "72,68");
1486                                 Assert.AreEqual (-6750157, bmp.GetPixel (72, 72).ToArgb (), "72,72");
1487                                 Assert.AreEqual (0, bmp.GetPixel (72, 76).ToArgb (), "72,76");
1488                                 Assert.AreEqual (0, bmp.GetPixel (72, 80).ToArgb (), "72,80");
1489                                 Assert.AreEqual (0, bmp.GetPixel (72, 84).ToArgb (), "72,84");
1490                                 Assert.AreEqual (0, bmp.GetPixel (72, 88).ToArgb (), "72,88");
1491                                 Assert.AreEqual (-39373, bmp.GetPixel (72, 92).ToArgb (), "72,92");
1492                                 Assert.AreEqual (0, bmp.GetPixel (76, 0).ToArgb (), "76,0");
1493                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 4).ToArgb (), "76,4");
1494                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 8).ToArgb (), "76,8");
1495                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 12).ToArgb (), "76,12");
1496                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 16).ToArgb (), "76,16");
1497                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 20).ToArgb (), "76,20");
1498                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 24).ToArgb (), "76,24");
1499                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 28).ToArgb (), "76,28");
1500                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 32).ToArgb (), "76,32");
1501                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 36).ToArgb (), "76,36");
1502                                 Assert.AreEqual (-52429, bmp.GetPixel (76, 40).ToArgb (), "76,40");
1503                                 Assert.AreEqual (-14935012, bmp.GetPixel (76, 44).ToArgb (), "76,44");
1504                                 Assert.AreEqual (-6750157, bmp.GetPixel (76, 48).ToArgb (), "76,48");
1505                                 Assert.AreEqual (-6750157, bmp.GetPixel (76, 52).ToArgb (), "76,52");
1506                                 Assert.AreEqual (-6750157, bmp.GetPixel (76, 56).ToArgb (), "76,56");
1507                                 Assert.AreEqual (-6750157, bmp.GetPixel (76, 60).ToArgb (), "76,60");
1508                                 Assert.AreEqual (-6750157, bmp.GetPixel (76, 64).ToArgb (), "76,64");
1509                                 Assert.AreEqual (-6750157, bmp.GetPixel (76, 68).ToArgb (), "76,68");
1510                                 Assert.AreEqual (-6750157, bmp.GetPixel (76, 72).ToArgb (), "76,72");
1511                                 Assert.AreEqual (-14935012, bmp.GetPixel (76, 76).ToArgb (), "76,76");
1512                                 Assert.AreEqual (0, bmp.GetPixel (76, 80).ToArgb (), "76,80");
1513                                 Assert.AreEqual (-65383, bmp.GetPixel (76, 84).ToArgb (), "76,84");
1514                                 Assert.AreEqual (-65383, bmp.GetPixel (76, 88).ToArgb (), "76,88");
1515                                 Assert.AreEqual (-14935012, bmp.GetPixel (76, 92).ToArgb (), "76,92");
1516                                 Assert.AreEqual (0, bmp.GetPixel (80, 0).ToArgb (), "80,0");
1517                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 4).ToArgb (), "80,4");
1518                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 8).ToArgb (), "80,8");
1519                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 12).ToArgb (), "80,12");
1520                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 16).ToArgb (), "80,16");
1521                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 20).ToArgb (), "80,20");
1522                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 24).ToArgb (), "80,24");
1523                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 28).ToArgb (), "80,28");
1524                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 32).ToArgb (), "80,32");
1525                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 36).ToArgb (), "80,36");
1526                                 Assert.AreEqual (-52429, bmp.GetPixel (80, 40).ToArgb (), "80,40");
1527                                 Assert.AreEqual (0, bmp.GetPixel (80, 44).ToArgb (), "80,44");
1528                                 Assert.AreEqual (-6750157, bmp.GetPixel (80, 48).ToArgb (), "80,48");
1529                                 Assert.AreEqual (-6750157, bmp.GetPixel (80, 52).ToArgb (), "80,52");
1530                                 Assert.AreEqual (-6750157, bmp.GetPixel (80, 56).ToArgb (), "80,56");
1531                                 Assert.AreEqual (-6750157, bmp.GetPixel (80, 60).ToArgb (), "80,60");
1532                                 Assert.AreEqual (-6750157, bmp.GetPixel (80, 64).ToArgb (), "80,64");
1533                                 Assert.AreEqual (-6750157, bmp.GetPixel (80, 68).ToArgb (), "80,68");
1534                                 Assert.AreEqual (-6750157, bmp.GetPixel (80, 72).ToArgb (), "80,72");
1535                                 Assert.AreEqual (-14935012, bmp.GetPixel (80, 76).ToArgb (), "80,76");
1536                                 Assert.AreEqual (-65383, bmp.GetPixel (80, 80).ToArgb (), "80,80");
1537                                 Assert.AreEqual (-65383, bmp.GetPixel (80, 84).ToArgb (), "80,84");
1538                                 Assert.AreEqual (-65383, bmp.GetPixel (80, 88).ToArgb (), "80,88");
1539                                 Assert.AreEqual (-65383, bmp.GetPixel (80, 92).ToArgb (), "80,92");
1540                                 Assert.AreEqual (0, bmp.GetPixel (84, 0).ToArgb (), "84,0");
1541                                 Assert.AreEqual (0, bmp.GetPixel (84, 4).ToArgb (), "84,4");
1542                                 Assert.AreEqual (-52429, bmp.GetPixel (84, 8).ToArgb (), "84,8");
1543                                 Assert.AreEqual (-52429, bmp.GetPixel (84, 12).ToArgb (), "84,12");
1544                                 Assert.AreEqual (-52429, bmp.GetPixel (84, 16).ToArgb (), "84,16");
1545                                 Assert.AreEqual (-52429, bmp.GetPixel (84, 20).ToArgb (), "84,20");
1546                                 Assert.AreEqual (-52429, bmp.GetPixel (84, 24).ToArgb (), "84,24");
1547                                 Assert.AreEqual (-52429, bmp.GetPixel (84, 28).ToArgb (), "84,28");
1548                                 Assert.AreEqual (-52429, bmp.GetPixel (84, 32).ToArgb (), "84,32");
1549                                 Assert.AreEqual (-52429, bmp.GetPixel (84, 36).ToArgb (), "84,36");
1550                                 Assert.AreEqual (-14935012, bmp.GetPixel (84, 40).ToArgb (), "84,40");
1551                                 Assert.AreEqual (0, bmp.GetPixel (84, 44).ToArgb (), "84,44");
1552                                 Assert.AreEqual (-14935012, bmp.GetPixel (84, 48).ToArgb (), "84,48");
1553                                 Assert.AreEqual (-6750157, bmp.GetPixel (84, 52).ToArgb (), "84,52");
1554                                 Assert.AreEqual (-6750157, bmp.GetPixel (84, 56).ToArgb (), "84,56");
1555                                 Assert.AreEqual (-6750157, bmp.GetPixel (84, 60).ToArgb (), "84,60");
1556                                 Assert.AreEqual (-6750157, bmp.GetPixel (84, 64).ToArgb (), "84,64");
1557                                 Assert.AreEqual (-6750157, bmp.GetPixel (84, 68).ToArgb (), "84,68");
1558                                 Assert.AreEqual (-6750157, bmp.GetPixel (84, 72).ToArgb (), "84,72");
1559                                 Assert.AreEqual (0, bmp.GetPixel (84, 76).ToArgb (), "84,76");
1560                                 Assert.AreEqual (-65383, bmp.GetPixel (84, 80).ToArgb (), "84,80");
1561                                 Assert.AreEqual (-65383, bmp.GetPixel (84, 84).ToArgb (), "84,84");
1562                                 Assert.AreEqual (-65383, bmp.GetPixel (84, 88).ToArgb (), "84,88");
1563                                 Assert.AreEqual (-65383, bmp.GetPixel (84, 92).ToArgb (), "84,92");
1564                                 Assert.AreEqual (0, bmp.GetPixel (88, 0).ToArgb (), "88,0");
1565                                 Assert.AreEqual (-3342490, bmp.GetPixel (88, 4).ToArgb (), "88,4");
1566                                 Assert.AreEqual (-14935012, bmp.GetPixel (88, 8).ToArgb (), "88,8");
1567                                 Assert.AreEqual (-52429, bmp.GetPixel (88, 12).ToArgb (), "88,12");
1568                                 Assert.AreEqual (-52429, bmp.GetPixel (88, 16).ToArgb (), "88,16");
1569                                 Assert.AreEqual (-52429, bmp.GetPixel (88, 20).ToArgb (), "88,20");
1570                                 Assert.AreEqual (-52429, bmp.GetPixel (88, 24).ToArgb (), "88,24");
1571                                 Assert.AreEqual (-52429, bmp.GetPixel (88, 28).ToArgb (), "88,28");
1572                                 Assert.AreEqual (-52429, bmp.GetPixel (88, 32).ToArgb (), "88,32");
1573                                 Assert.AreEqual (-52429, bmp.GetPixel (88, 36).ToArgb (), "88,36");
1574                                 Assert.AreEqual (0, bmp.GetPixel (88, 40).ToArgb (), "88,40");
1575                                 Assert.AreEqual (-16777063, bmp.GetPixel (88, 44).ToArgb (), "88,44");
1576                                 Assert.AreEqual (0, bmp.GetPixel (88, 48).ToArgb (), "88,48");
1577                                 Assert.AreEqual (-6750157, bmp.GetPixel (88, 52).ToArgb (), "88,52");
1578                                 Assert.AreEqual (-6750157, bmp.GetPixel (88, 56).ToArgb (), "88,56");
1579                                 Assert.AreEqual (-6750157, bmp.GetPixel (88, 60).ToArgb (), "88,60");
1580                                 Assert.AreEqual (-6750157, bmp.GetPixel (88, 64).ToArgb (), "88,64");
1581                                 Assert.AreEqual (-6750157, bmp.GetPixel (88, 68).ToArgb (), "88,68");
1582                                 Assert.AreEqual (-6750157, bmp.GetPixel (88, 72).ToArgb (), "88,72");
1583                                 Assert.AreEqual (0, bmp.GetPixel (88, 76).ToArgb (), "88,76");
1584                                 Assert.AreEqual (-65383, bmp.GetPixel (88, 80).ToArgb (), "88,80");
1585                                 Assert.AreEqual (-65383, bmp.GetPixel (88, 84).ToArgb (), "88,84");
1586                                 Assert.AreEqual (-65383, bmp.GetPixel (88, 88).ToArgb (), "88,88");
1587                                 Assert.AreEqual (-65383, bmp.GetPixel (88, 92).ToArgb (), "88,92");
1588                                 Assert.AreEqual (-14935012, bmp.GetPixel (92, 0).ToArgb (), "92,0");
1589                                 Assert.AreEqual (-3342490, bmp.GetPixel (92, 4).ToArgb (), "92,4");
1590                                 Assert.AreEqual (-14935012, bmp.GetPixel (92, 8).ToArgb (), "92,8");
1591                                 Assert.AreEqual (0, bmp.GetPixel (92, 12).ToArgb (), "92,12");
1592                                 Assert.AreEqual (-52429, bmp.GetPixel (92, 16).ToArgb (), "92,16");
1593                                 Assert.AreEqual (-52429, bmp.GetPixel (92, 20).ToArgb (), "92,20");
1594                                 Assert.AreEqual (-52429, bmp.GetPixel (92, 24).ToArgb (), "92,24");
1595                                 Assert.AreEqual (-52429, bmp.GetPixel (92, 28).ToArgb (), "92,28");
1596                                 Assert.AreEqual (-14935012, bmp.GetPixel (92, 32).ToArgb (), "92,32");
1597                                 Assert.AreEqual (0, bmp.GetPixel (92, 36).ToArgb (), "92,36");
1598                                 Assert.AreEqual (0, bmp.GetPixel (92, 40).ToArgb (), "92,40");
1599                                 Assert.AreEqual (0, bmp.GetPixel (92, 44).ToArgb (), "92,44");
1600                                 Assert.AreEqual (0, bmp.GetPixel (92, 48).ToArgb (), "92,48");
1601                                 Assert.AreEqual (0, bmp.GetPixel (92, 52).ToArgb (), "92,52");
1602                                 Assert.AreEqual (-6750157, bmp.GetPixel (92, 56).ToArgb (), "92,56");
1603                                 Assert.AreEqual (-6750157, bmp.GetPixel (92, 60).ToArgb (), "92,60");
1604                                 Assert.AreEqual (-6750157, bmp.GetPixel (92, 64).ToArgb (), "92,64");
1605                                 Assert.AreEqual (-6750157, bmp.GetPixel (92, 68).ToArgb (), "92,68");
1606                                 Assert.AreEqual (0, bmp.GetPixel (92, 72).ToArgb (), "92,72");
1607                                 Assert.AreEqual (0, bmp.GetPixel (92, 76).ToArgb (), "92,76");
1608                                 Assert.AreEqual (-65383, bmp.GetPixel (92, 80).ToArgb (), "92,80");
1609                                 Assert.AreEqual (-65383, bmp.GetPixel (92, 84).ToArgb (), "92,84");
1610                                 Assert.AreEqual (-65383, bmp.GetPixel (92, 88).ToArgb (), "92,88");
1611                                 Assert.AreEqual (-65383, bmp.GetPixel (92, 92).ToArgb (), "92,92");
1612 #endif
1613                         }
1614                 }
1615
1616                 [Test]
1617                 public void Bitmat96Data ()
1618                 {
1619                         string sInFile = getInFile ("bitmaps/96x96x256.ico");
1620                         using (Bitmap bmp = new Bitmap (sInFile)) {
1621                                 BitmapData data = bmp.LockBits (new Rectangle (0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
1622                                 try {
1623                                         Assert.AreEqual (bmp.Height, data.Height, "Height");
1624                                         Assert.AreEqual (bmp.Width, data.Width, "Width");
1625                                         Assert.AreEqual (PixelFormat.Format24bppRgb, data.PixelFormat, "PixelFormat");
1626                                         int size = data.Height * data.Stride;
1627                                         unsafe {
1628                                                 byte* scan = (byte*) data.Scan0;
1629 #if false
1630                                                 // 97 is prime (so we're not affected by a recurring pattern)
1631                                                 for (int p = 0; p < size; p += 97) {
1632                                                         Console.WriteLine ("\t\t\t\t\t\tAssert.AreEqual ({0}, *(scan + {1}), \"{1}\");", *(scan + p), p);
1633                                                 }
1634 #else
1635                                                 // sampling values from a well known bitmap
1636                                                 Assert.AreEqual (0, *(scan + 0), "0");
1637                                                 Assert.AreEqual (0, *(scan + 97), "97");
1638                                                 Assert.AreEqual (0, *(scan + 194), "194");
1639                                                 Assert.AreEqual (0, *(scan + 291), "291");
1640                                                 Assert.AreEqual (0, *(scan + 388), "388");
1641                                                 Assert.AreEqual (28, *(scan + 485), "485");
1642                                                 Assert.AreEqual (0, *(scan + 582), "582");
1643                                                 Assert.AreEqual (28, *(scan + 679), "679");
1644                                                 Assert.AreEqual (255, *(scan + 776), "776");
1645                                                 Assert.AreEqual (0, *(scan + 873), "873");
1646                                                 Assert.AreEqual (255, *(scan + 970), "970");
1647                                                 Assert.AreEqual (255, *(scan + 1067), "1067");
1648                                                 Assert.AreEqual (0, *(scan + 1164), "1164");
1649                                                 Assert.AreEqual (255, *(scan + 1261), "1261");
1650                                                 Assert.AreEqual (255, *(scan + 1358), "1358");
1651                                                 Assert.AreEqual (0, *(scan + 1455), "1455");
1652                                                 Assert.AreEqual (255, *(scan + 1552), "1552");
1653                                                 Assert.AreEqual (255, *(scan + 1649), "1649");
1654                                                 Assert.AreEqual (0, *(scan + 1746), "1746");
1655                                                 Assert.AreEqual (255, *(scan + 1843), "1843");
1656                                                 Assert.AreEqual (255, *(scan + 1940), "1940");
1657                                                 Assert.AreEqual (0, *(scan + 2037), "2037");
1658                                                 Assert.AreEqual (255, *(scan + 2134), "2134");
1659                                                 Assert.AreEqual (255, *(scan + 2231), "2231");
1660                                                 Assert.AreEqual (0, *(scan + 2328), "2328");
1661                                                 Assert.AreEqual (255, *(scan + 2425), "2425");
1662                                                 Assert.AreEqual (255, *(scan + 2522), "2522");
1663                                                 Assert.AreEqual (0, *(scan + 2619), "2619");
1664                                                 Assert.AreEqual (255, *(scan + 2716), "2716");
1665                                                 Assert.AreEqual (255, *(scan + 2813), "2813");
1666                                                 Assert.AreEqual (0, *(scan + 2910), "2910");
1667                                                 Assert.AreEqual (255, *(scan + 3007), "3007");
1668                                                 Assert.AreEqual (255, *(scan + 3104), "3104");
1669                                                 Assert.AreEqual (0, *(scan + 3201), "3201");
1670                                                 Assert.AreEqual (255, *(scan + 3298), "3298");
1671                                                 Assert.AreEqual (255, *(scan + 3395), "3395");
1672                                                 Assert.AreEqual (0, *(scan + 3492), "3492");
1673                                                 Assert.AreEqual (0, *(scan + 3589), "3589");
1674                                                 Assert.AreEqual (255, *(scan + 3686), "3686");
1675                                                 Assert.AreEqual (0, *(scan + 3783), "3783");
1676                                                 Assert.AreEqual (0, *(scan + 3880), "3880");
1677                                                 Assert.AreEqual (255, *(scan + 3977), "3977");
1678                                                 Assert.AreEqual (0, *(scan + 4074), "4074");
1679                                                 Assert.AreEqual (0, *(scan + 4171), "4171");
1680                                                 Assert.AreEqual (255, *(scan + 4268), "4268");
1681                                                 Assert.AreEqual (0, *(scan + 4365), "4365");
1682                                                 Assert.AreEqual (28, *(scan + 4462), "4462");
1683                                                 Assert.AreEqual (255, *(scan + 4559), "4559");
1684                                                 Assert.AreEqual (0, *(scan + 4656), "4656");
1685                                                 Assert.AreEqual (51, *(scan + 4753), "4753");
1686                                                 Assert.AreEqual (255, *(scan + 4850), "4850");
1687                                                 Assert.AreEqual (0, *(scan + 4947), "4947");
1688                                                 Assert.AreEqual (51, *(scan + 5044), "5044");
1689                                                 Assert.AreEqual (255, *(scan + 5141), "5141");
1690                                                 Assert.AreEqual (0, *(scan + 5238), "5238");
1691                                                 Assert.AreEqual (51, *(scan + 5335), "5335");
1692                                                 Assert.AreEqual (255, *(scan + 5432), "5432");
1693                                                 Assert.AreEqual (0, *(scan + 5529), "5529");
1694                                                 Assert.AreEqual (51, *(scan + 5626), "5626");
1695                                                 Assert.AreEqual (255, *(scan + 5723), "5723");
1696                                                 Assert.AreEqual (0, *(scan + 5820), "5820");
1697                                                 Assert.AreEqual (51, *(scan + 5917), "5917");
1698                                                 Assert.AreEqual (255, *(scan + 6014), "6014");
1699                                                 Assert.AreEqual (0, *(scan + 6111), "6111");
1700                                                 Assert.AreEqual (51, *(scan + 6208), "6208");
1701                                                 Assert.AreEqual (255, *(scan + 6305), "6305");
1702                                                 Assert.AreEqual (0, *(scan + 6402), "6402");
1703                                                 Assert.AreEqual (51, *(scan + 6499), "6499");
1704                                                 Assert.AreEqual (255, *(scan + 6596), "6596");
1705                                                 Assert.AreEqual (0, *(scan + 6693), "6693");
1706                                                 Assert.AreEqual (51, *(scan + 6790), "6790");
1707                                                 Assert.AreEqual (255, *(scan + 6887), "6887");
1708                                                 Assert.AreEqual (0, *(scan + 6984), "6984");
1709                                                 Assert.AreEqual (51, *(scan + 7081), "7081");
1710                                                 Assert.AreEqual (255, *(scan + 7178), "7178");
1711                                                 Assert.AreEqual (0, *(scan + 7275), "7275");
1712                                                 Assert.AreEqual (51, *(scan + 7372), "7372");
1713                                                 Assert.AreEqual (255, *(scan + 7469), "7469");
1714                                                 Assert.AreEqual (0, *(scan + 7566), "7566");
1715                                                 Assert.AreEqual (51, *(scan + 7663), "7663");
1716                                                 Assert.AreEqual (255, *(scan + 7760), "7760");
1717                                                 Assert.AreEqual (0, *(scan + 7857), "7857");
1718                                                 Assert.AreEqual (51, *(scan + 7954), "7954");
1719                                                 Assert.AreEqual (255, *(scan + 8051), "8051");
1720                                                 Assert.AreEqual (0, *(scan + 8148), "8148");
1721                                                 Assert.AreEqual (51, *(scan + 8245), "8245");
1722                                                 Assert.AreEqual (255, *(scan + 8342), "8342");
1723                                                 Assert.AreEqual (0, *(scan + 8439), "8439");
1724                                                 Assert.AreEqual (51, *(scan + 8536), "8536");
1725                                                 Assert.AreEqual (28, *(scan + 8633), "8633");
1726                                                 Assert.AreEqual (0, *(scan + 8730), "8730");
1727                                                 Assert.AreEqual (51, *(scan + 8827), "8827");
1728                                                 Assert.AreEqual (0, *(scan + 8924), "8924");
1729                                                 Assert.AreEqual (0, *(scan + 9021), "9021");
1730                                                 Assert.AreEqual (51, *(scan + 9118), "9118");
1731                                                 Assert.AreEqual (0, *(scan + 9215), "9215");
1732                                                 Assert.AreEqual (0, *(scan + 9312), "9312");
1733                                                 Assert.AreEqual (51, *(scan + 9409), "9409");
1734                                                 Assert.AreEqual (0, *(scan + 9506), "9506");
1735                                                 Assert.AreEqual (0, *(scan + 9603), "9603");
1736                                                 Assert.AreEqual (51, *(scan + 9700), "9700");
1737                                                 Assert.AreEqual (0, *(scan + 9797), "9797");
1738                                                 Assert.AreEqual (28, *(scan + 9894), "9894");
1739                                                 Assert.AreEqual (51, *(scan + 9991), "9991");
1740                                                 Assert.AreEqual (0, *(scan + 10088), "10088");
1741                                                 Assert.AreEqual (0, *(scan + 10185), "10185");
1742                                                 Assert.AreEqual (51, *(scan + 10282), "10282");
1743                                                 Assert.AreEqual (0, *(scan + 10379), "10379");
1744                                                 Assert.AreEqual (0, *(scan + 10476), "10476");
1745                                                 Assert.AreEqual (51, *(scan + 10573), "10573");
1746                                                 Assert.AreEqual (0, *(scan + 10670), "10670");
1747                                                 Assert.AreEqual (0, *(scan + 10767), "10767");
1748                                                 Assert.AreEqual (51, *(scan + 10864), "10864");
1749                                                 Assert.AreEqual (204, *(scan + 10961), "10961");
1750                                                 Assert.AreEqual (0, *(scan + 11058), "11058");
1751                                                 Assert.AreEqual (51, *(scan + 11155), "11155");
1752                                                 Assert.AreEqual (204, *(scan + 11252), "11252");
1753                                                 Assert.AreEqual (0, *(scan + 11349), "11349");
1754                                                 Assert.AreEqual (51, *(scan + 11446), "11446");
1755                                                 Assert.AreEqual (204, *(scan + 11543), "11543");
1756                                                 Assert.AreEqual (0, *(scan + 11640), "11640");
1757                                                 Assert.AreEqual (51, *(scan + 11737), "11737");
1758                                                 Assert.AreEqual (204, *(scan + 11834), "11834");
1759                                                 Assert.AreEqual (0, *(scan + 11931), "11931");
1760                                                 Assert.AreEqual (51, *(scan + 12028), "12028");
1761                                                 Assert.AreEqual (204, *(scan + 12125), "12125");
1762                                                 Assert.AreEqual (0, *(scan + 12222), "12222");
1763                                                 Assert.AreEqual (51, *(scan + 12319), "12319");
1764                                                 Assert.AreEqual (204, *(scan + 12416), "12416");
1765                                                 Assert.AreEqual (28, *(scan + 12513), "12513");
1766                                                 Assert.AreEqual (51, *(scan + 12610), "12610");
1767                                                 Assert.AreEqual (204, *(scan + 12707), "12707");
1768                                                 Assert.AreEqual (0, *(scan + 12804), "12804");
1769                                                 Assert.AreEqual (28, *(scan + 12901), "12901");
1770                                                 Assert.AreEqual (204, *(scan + 12998), "12998");
1771                                                 Assert.AreEqual (0, *(scan + 13095), "13095");
1772                                                 Assert.AreEqual (0, *(scan + 13192), "13192");
1773                                                 Assert.AreEqual (204, *(scan + 13289), "13289");
1774                                                 Assert.AreEqual (0, *(scan + 13386), "13386");
1775                                                 Assert.AreEqual (0, *(scan + 13483), "13483");
1776                                                 Assert.AreEqual (204, *(scan + 13580), "13580");
1777                                                 Assert.AreEqual (0, *(scan + 13677), "13677");
1778                                                 Assert.AreEqual (28, *(scan + 13774), "13774");
1779                                                 Assert.AreEqual (204, *(scan + 13871), "13871");
1780                                                 Assert.AreEqual (0, *(scan + 13968), "13968");
1781                                                 Assert.AreEqual (0, *(scan + 14065), "14065");
1782                                                 Assert.AreEqual (204, *(scan + 14162), "14162");
1783                                                 Assert.AreEqual (0, *(scan + 14259), "14259");
1784                                                 Assert.AreEqual (0, *(scan + 14356), "14356");
1785                                                 Assert.AreEqual (204, *(scan + 14453), "14453");
1786                                                 Assert.AreEqual (0, *(scan + 14550), "14550");
1787                                                 Assert.AreEqual (0, *(scan + 14647), "14647");
1788                                                 Assert.AreEqual (204, *(scan + 14744), "14744");
1789                                                 Assert.AreEqual (0, *(scan + 14841), "14841");
1790                                                 Assert.AreEqual (0, *(scan + 14938), "14938");
1791                                                 Assert.AreEqual (204, *(scan + 15035), "15035");
1792                                                 Assert.AreEqual (0, *(scan + 15132), "15132");
1793                                                 Assert.AreEqual (0, *(scan + 15229), "15229");
1794                                                 Assert.AreEqual (204, *(scan + 15326), "15326");
1795                                                 Assert.AreEqual (0, *(scan + 15423), "15423");
1796                                                 Assert.AreEqual (0, *(scan + 15520), "15520");
1797                                                 Assert.AreEqual (204, *(scan + 15617), "15617");
1798                                                 Assert.AreEqual (0, *(scan + 15714), "15714");
1799                                                 Assert.AreEqual (0, *(scan + 15811), "15811");
1800                                                 Assert.AreEqual (204, *(scan + 15908), "15908");
1801                                                 Assert.AreEqual (0, *(scan + 16005), "16005");
1802                                                 Assert.AreEqual (0, *(scan + 16102), "16102");
1803                                                 Assert.AreEqual (204, *(scan + 16199), "16199");
1804                                                 Assert.AreEqual (0, *(scan + 16296), "16296");
1805                                                 Assert.AreEqual (0, *(scan + 16393), "16393");
1806                                                 Assert.AreEqual (204, *(scan + 16490), "16490");
1807                                                 Assert.AreEqual (0, *(scan + 16587), "16587");
1808                                                 Assert.AreEqual (0, *(scan + 16684), "16684");
1809                                                 Assert.AreEqual (204, *(scan + 16781), "16781");
1810                                                 Assert.AreEqual (0, *(scan + 16878), "16878");
1811                                                 Assert.AreEqual (0, *(scan + 16975), "16975");
1812                                                 Assert.AreEqual (204, *(scan + 17072), "17072");
1813                                                 Assert.AreEqual (0, *(scan + 17169), "17169");
1814                                                 Assert.AreEqual (0, *(scan + 17266), "17266");
1815                                                 Assert.AreEqual (204, *(scan + 17363), "17363");
1816                                                 Assert.AreEqual (0, *(scan + 17460), "17460");
1817                                                 Assert.AreEqual (0, *(scan + 17557), "17557");
1818                                                 Assert.AreEqual (28, *(scan + 17654), "17654");
1819                                                 Assert.AreEqual (0, *(scan + 17751), "17751");
1820                                                 Assert.AreEqual (0, *(scan + 17848), "17848");
1821                                                 Assert.AreEqual (0, *(scan + 17945), "17945");
1822                                                 Assert.AreEqual (28, *(scan + 18042), "18042");
1823                                                 Assert.AreEqual (0, *(scan + 18139), "18139");
1824                                                 Assert.AreEqual (0, *(scan + 18236), "18236");
1825                                                 Assert.AreEqual (51, *(scan + 18333), "18333");
1826                                                 Assert.AreEqual (28, *(scan + 18430), "18430");
1827                                                 Assert.AreEqual (0, *(scan + 18527), "18527");
1828                                                 Assert.AreEqual (51, *(scan + 18624), "18624");
1829                                                 Assert.AreEqual (0, *(scan + 18721), "18721");
1830                                                 Assert.AreEqual (28, *(scan + 18818), "18818");
1831                                                 Assert.AreEqual (51, *(scan + 18915), "18915");
1832                                                 Assert.AreEqual (255, *(scan + 19012), "19012");
1833                                                 Assert.AreEqual (51, *(scan + 19109), "19109");
1834                                                 Assert.AreEqual (51, *(scan + 19206), "19206");
1835                                                 Assert.AreEqual (255, *(scan + 19303), "19303");
1836                                                 Assert.AreEqual (51, *(scan + 19400), "19400");
1837                                                 Assert.AreEqual (51, *(scan + 19497), "19497");
1838                                                 Assert.AreEqual (255, *(scan + 19594), "19594");
1839                                                 Assert.AreEqual (51, *(scan + 19691), "19691");
1840                                                 Assert.AreEqual (51, *(scan + 19788), "19788");
1841                                                 Assert.AreEqual (255, *(scan + 19885), "19885");
1842                                                 Assert.AreEqual (51, *(scan + 19982), "19982");
1843                                                 Assert.AreEqual (51, *(scan + 20079), "20079");
1844                                                 Assert.AreEqual (255, *(scan + 20176), "20176");
1845                                                 Assert.AreEqual (51, *(scan + 20273), "20273");
1846                                                 Assert.AreEqual (51, *(scan + 20370), "20370");
1847                                                 Assert.AreEqual (255, *(scan + 20467), "20467");
1848                                                 Assert.AreEqual (51, *(scan + 20564), "20564");
1849                                                 Assert.AreEqual (51, *(scan + 20661), "20661");
1850                                                 Assert.AreEqual (255, *(scan + 20758), "20758");
1851                                                 Assert.AreEqual (51, *(scan + 20855), "20855");
1852                                                 Assert.AreEqual (51, *(scan + 20952), "20952");
1853                                                 Assert.AreEqual (255, *(scan + 21049), "21049");
1854                                                 Assert.AreEqual (51, *(scan + 21146), "21146");
1855                                                 Assert.AreEqual (51, *(scan + 21243), "21243");
1856                                                 Assert.AreEqual (28, *(scan + 21340), "21340");
1857                                                 Assert.AreEqual (51, *(scan + 21437), "21437");
1858                                                 Assert.AreEqual (51, *(scan + 21534), "21534");
1859                                                 Assert.AreEqual (0, *(scan + 21631), "21631");
1860                                                 Assert.AreEqual (51, *(scan + 21728), "21728");
1861                                                 Assert.AreEqual (28, *(scan + 21825), "21825");
1862                                                 Assert.AreEqual (0, *(scan + 21922), "21922");
1863                                                 Assert.AreEqual (51, *(scan + 22019), "22019");
1864                                                 Assert.AreEqual (28, *(scan + 22116), "22116");
1865                                                 Assert.AreEqual (0, *(scan + 22213), "22213");
1866                                                 Assert.AreEqual (51, *(scan + 22310), "22310");
1867                                                 Assert.AreEqual (0, *(scan + 22407), "22407");
1868                                                 Assert.AreEqual (0, *(scan + 22504), "22504");
1869                                                 Assert.AreEqual (51, *(scan + 22601), "22601");
1870                                                 Assert.AreEqual (0, *(scan + 22698), "22698");
1871                                                 Assert.AreEqual (0, *(scan + 22795), "22795");
1872                                                 Assert.AreEqual (51, *(scan + 22892), "22892");
1873                                                 Assert.AreEqual (28, *(scan + 22989), "22989");
1874                                                 Assert.AreEqual (0, *(scan + 23086), "23086");
1875                                                 Assert.AreEqual (28, *(scan + 23183), "23183");
1876                                                 Assert.AreEqual (153, *(scan + 23280), "23280");
1877                                                 Assert.AreEqual (28, *(scan + 23377), "23377");
1878                                                 Assert.AreEqual (0, *(scan + 23474), "23474");
1879                                                 Assert.AreEqual (153, *(scan + 23571), "23571");
1880                                                 Assert.AreEqual (28, *(scan + 23668), "23668");
1881                                                 Assert.AreEqual (0, *(scan + 23765), "23765");
1882                                                 Assert.AreEqual (153, *(scan + 23862), "23862");
1883                                                 Assert.AreEqual (0, *(scan + 23959), "23959");
1884                                                 Assert.AreEqual (28, *(scan + 24056), "24056");
1885                                                 Assert.AreEqual (153, *(scan + 24153), "24153");
1886                                                 Assert.AreEqual (0, *(scan + 24250), "24250");
1887                                                 Assert.AreEqual (153, *(scan + 24347), "24347");
1888                                                 Assert.AreEqual (153, *(scan + 24444), "24444");
1889                                                 Assert.AreEqual (0, *(scan + 24541), "24541");
1890                                                 Assert.AreEqual (153, *(scan + 24638), "24638");
1891                                                 Assert.AreEqual (153, *(scan + 24735), "24735");
1892                                                 Assert.AreEqual (0, *(scan + 24832), "24832");
1893                                                 Assert.AreEqual (153, *(scan + 24929), "24929");
1894                                                 Assert.AreEqual (153, *(scan + 25026), "25026");
1895                                                 Assert.AreEqual (0, *(scan + 25123), "25123");
1896                                                 Assert.AreEqual (153, *(scan + 25220), "25220");
1897                                                 Assert.AreEqual (153, *(scan + 25317), "25317");
1898                                                 Assert.AreEqual (0, *(scan + 25414), "25414");
1899                                                 Assert.AreEqual (153, *(scan + 25511), "25511");
1900                                                 Assert.AreEqual (153, *(scan + 25608), "25608");
1901                                                 Assert.AreEqual (0, *(scan + 25705), "25705");
1902                                                 Assert.AreEqual (153, *(scan + 25802), "25802");
1903                                                 Assert.AreEqual (153, *(scan + 25899), "25899");
1904                                                 Assert.AreEqual (0, *(scan + 25996), "25996");
1905                                                 Assert.AreEqual (153, *(scan + 26093), "26093");
1906                                                 Assert.AreEqual (153, *(scan + 26190), "26190");
1907                                                 Assert.AreEqual (0, *(scan + 26287), "26287");
1908                                                 Assert.AreEqual (153, *(scan + 26384), "26384");
1909                                                 Assert.AreEqual (153, *(scan + 26481), "26481");
1910                                                 Assert.AreEqual (0, *(scan + 26578), "26578");
1911                                                 Assert.AreEqual (153, *(scan + 26675), "26675");
1912                                                 Assert.AreEqual (153, *(scan + 26772), "26772");
1913                                                 Assert.AreEqual (28, *(scan + 26869), "26869");
1914                                                 Assert.AreEqual (153, *(scan + 26966), "26966");
1915                                                 Assert.AreEqual (28, *(scan + 27063), "27063");
1916                                                 Assert.AreEqual (28, *(scan + 27160), "27160");
1917                                                 Assert.AreEqual (28, *(scan + 27257), "27257");
1918                                                 Assert.AreEqual (0, *(scan + 27354), "27354");
1919                                                 Assert.AreEqual (0, *(scan + 27451), "27451");
1920                                                 Assert.AreEqual (0, *(scan + 27548), "27548");
1921                                                 Assert.AreEqual (0, *(scan + 27645), "27645");
1922 #endif
1923                                         }
1924                                 }
1925                                 finally {
1926                                         bmp.UnlockBits (data);
1927                                 }
1928                         }
1929                 }
1930
1931                 [Test]
1932                 public void Xp32bppIconFeatures ()
1933                 {
1934                         string sInFile = getInFile ("bitmaps/32bpp.ico");
1935                         using (Bitmap bmp = new Bitmap (sInFile)) {
1936                                 GraphicsUnit unit = GraphicsUnit.World;
1937                                 RectangleF rect = bmp.GetBounds (ref unit);
1938
1939                                 Assert.IsTrue (bmp.RawFormat.Equals (ImageFormat.Icon), "Icon");
1940                                 // note that image is "promoted" to 32bits
1941                                 Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
1942                                 Assert.AreEqual (73746, bmp.Flags, "bmp.Flags");
1943                                 Assert.AreEqual (0, bmp.Palette.Entries.Length, "Palette");
1944                                 Assert.AreEqual (1, bmp.FrameDimensionsList.Length, "FrameDimensionsList");
1945                                 Assert.AreEqual (0, bmp.PropertyIdList.Length, "PropertyIdList");
1946                                 Assert.AreEqual (0, bmp.PropertyItems.Length, "PropertyItems");
1947 #if NET_2_0
1948                                 Assert.IsNull (bmp.Tag, "Tag");
1949 #endif
1950                                 Assert.AreEqual (96.0f, bmp.HorizontalResolution, "HorizontalResolution");
1951                                 Assert.AreEqual (96.0f, bmp.VerticalResolution, "VerticalResolution");
1952                                 Assert.AreEqual (16, bmp.Width, "bmp.Width");
1953                                 Assert.AreEqual (16, bmp.Height, "bmp.Height");
1954
1955                                 Assert.AreEqual (0, rect.X, "rect.X");
1956                                 Assert.AreEqual (0, rect.Y, "rect.Y");
1957                                 Assert.AreEqual (16, rect.Width, "rect.Width");
1958                                 Assert.AreEqual (16, rect.Height, "rect.Height");
1959
1960                                 Assert.AreEqual (16, bmp.Size.Width, "bmp.Size.Width");
1961                                 Assert.AreEqual (16, bmp.Size.Height, "bmp.Size.Height");
1962                         }
1963                 }
1964
1965                 private void Save (PixelFormat original, PixelFormat expected, bool colorCheck)
1966                 {
1967                         string sOutFile = "linerect" + getOutSufix () + ".ico";
1968
1969                         // Save
1970                         Bitmap bmp = new Bitmap (100, 100, original);
1971                         Graphics gr = Graphics.FromImage (bmp);
1972
1973                         using (Pen p = new Pen (Color.Red, 2)) {
1974                                 gr.DrawLine (p, 10.0F, 10.0F, 90.0F, 90.0F);
1975                                 gr.DrawRectangle (p, 10.0F, 10.0F, 80.0F, 80.0F);
1976                         }
1977
1978                         try {
1979                                 // there's no encoder, so we're not saving a ICO but the alpha
1980                                 // bit get sets so it's not like saving a bitmap either
1981                                 bmp.Save (sOutFile, ImageFormat.Icon);
1982
1983                                 // Load
1984                                 using (Bitmap bmpLoad = new Bitmap (sOutFile)) {
1985                                         Assert.AreEqual (ImageFormat.Png, bmpLoad.RawFormat, "Png");
1986                                         Assert.AreEqual (expected, bmpLoad.PixelFormat, "PixelFormat");
1987                                         if (colorCheck) {
1988                                                 Color color = bmpLoad.GetPixel (10, 10);
1989                                                 Assert.AreEqual (Color.FromArgb (255, 255, 0, 0), color, "Red");
1990                                         }
1991                                 }
1992                         }
1993                         finally {
1994                                 gr.Dispose ();
1995                                 bmp.Dispose ();
1996                                 try {
1997                                         File.Delete (sOutFile);
1998                                 }
1999                                 catch {
2000                                 }
2001                         }
2002                 }
2003
2004                 [Test]
2005                 public void Save_24bppRgb ()
2006                 {
2007                         Save (PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb, true);
2008                 }
2009
2010                 [Test]
2011                 public void Save_32bppRgb ()
2012                 {
2013                         Save (PixelFormat.Format32bppRgb, PixelFormat.Format32bppArgb, true);
2014                 }
2015
2016                 [Test]
2017                 public void Save_32bppArgb ()
2018                 {
2019                         Save (PixelFormat.Format32bppArgb, PixelFormat.Format32bppArgb, true);
2020                 }
2021
2022                 [Test]
2023                 public void Save_32bppPArgb ()
2024                 {
2025                         Save (PixelFormat.Format32bppPArgb, PixelFormat.Format32bppArgb, true);
2026                 }
2027
2028                 [Test]
2029                 [Category ("NotWorking")]
2030                 public void Save_48bppRgb ()
2031                 {
2032                         Save (PixelFormat.Format48bppRgb, PixelFormat.Format48bppRgb, false);
2033                 }
2034
2035                 [Test]
2036                 [Category ("NotWorking")]
2037                 public void Save_64bppArgb ()
2038                 {
2039                         Save (PixelFormat.Format64bppArgb, PixelFormat.Format64bppArgb, false);
2040                 }
2041
2042                 [Test]
2043                 [Category ("NotWorking")]
2044                 public void Save_64bppPArgb ()
2045                 {
2046                         Save (PixelFormat.Format64bppPArgb, PixelFormat.Format64bppArgb, false);
2047                 }
2048         }
2049 }