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

   1 //
   2 // PNG 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 PngCodecTest {
  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) || (p == 6))
  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                 private bool IsArm64Process ()
  75                 {
  76                         if (Environment.OSVersion.Platform != PlatformID.Unix || !Environment.Is64BitProcess)
  77                                 return false;
  78
  79                         try {
  80                                 var process = new global::System.Diagnostics.Process ();
  81                                 process.StartInfo.FileName = "uname";
  82                                 process.StartInfo.Arguments = "-m";
  83                                 process.StartInfo.RedirectStandardOutput = true;
  84                                 process.StartInfo.UseShellExecute = false;
  85                                 process.Start ();
  86                                 process.WaitForExit ();
  87                                 var output = process.StandardOutput.ReadToEnd ();
  88
  89                                 return output.Trim () == "aarch64";
  90                         } catch {
  91                                 return false;
  92                         }
  93                 }
  94
  95                 /* Checks bitmap features on a known 1bbp bitmap */
  96                 [Test]
  97                 public void Bitmap1bitFeatures ()
  98                 {
  99                         string sInFile = getInFile ("bitmaps/1bit.png");
 100                         using (Bitmap bmp = new Bitmap (sInFile)) {
 101                                 GraphicsUnit unit = GraphicsUnit.World;
 102                                 RectangleF rect = bmp.GetBounds (ref unit);
 103
 104                                 Assert.AreEqual (PixelFormat.Format1bppIndexed, bmp.PixelFormat);
 105
 106                                 Assert.AreEqual (0, bmp.Palette.Flags, "Palette.Flags");
 107                                 Assert.AreEqual (2, bmp.Palette.Entries.Length, "Palette.Entries");
 108                                 Assert.AreEqual (-16777216, bmp.Palette.Entries[0].ToArgb (), "Palette.0");
 109                                 Assert.AreEqual (-1, bmp.Palette.Entries[1].ToArgb (), "Palette.1");
 110
 111                                 Assert.AreEqual (288, bmp.Width, "bmp.Width");
 112                                 Assert.AreEqual (384, bmp.Height, "bmp.Height");
 113
 114                                 Assert.AreEqual (0, rect.X, "rect.X");
 115                                 Assert.AreEqual (0, rect.Y, "rect.Y");
 116                                 Assert.AreEqual (288, rect.Width, "rect.Width");
 117                                 Assert.AreEqual (384, rect.Height, "rect.Height");
 118
 119                                 Assert.AreEqual (288, bmp.Size.Width, "bmp.Size.Width");
 120                                 Assert.AreEqual (384, bmp.Size.Height, "bmp.Size.Height");
 121                         }
 122                 }
 123
 124                 [Test]
 125                 public void Bitmap1bitPixels ()
 126                 {
 127                         string sInFile = getInFile ("bitmaps/1bit.png");
 128                         using (Bitmap bmp = new Bitmap (sInFile)) {
 129 #if false
 130                                 for (int x = 0; x < bmp.Width; x += 32) {
 131                                         for (int y = 0; y < bmp.Height; y += 32)
 132                                                 Console.WriteLine ("\t\t\t\tAssert.AreEqual ({0}, bmp.GetPixel ({1}, {2}).ToArgb (), \"{1},{2}\");", bmp.GetPixel (x, y).ToArgb (), x, y);
 133                                 }
 134 #else
 135                                 // sampling values from a well known bitmap
 136                                 Assert.AreEqual (-1, bmp.GetPixel (0, 0).ToArgb (), "0,0");
 137                                 Assert.AreEqual (-1, bmp.GetPixel (0, 32).ToArgb (), "0,32");
 138                                 Assert.AreEqual (-1, bmp.GetPixel (0, 64).ToArgb (), "0,64");
 139                                 Assert.AreEqual (-1, bmp.GetPixel (0, 96).ToArgb (), "0,96");
 140                                 Assert.AreEqual (-1, bmp.GetPixel (0, 128).ToArgb (), "0,128");
 141                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 160).ToArgb (), "0,160");
 142                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 192).ToArgb (), "0,192");
 143                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 224).ToArgb (), "0,224");
 144                                 Assert.AreEqual (-1, bmp.GetPixel (0, 256).ToArgb (), "0,256");
 145                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 288).ToArgb (), "0,288");
 146                                 Assert.AreEqual (-1, bmp.GetPixel (0, 320).ToArgb (), "0,320");
 147                                 Assert.AreEqual (-16777216, bmp.GetPixel (0, 352).ToArgb (), "0,352");
 148                                 Assert.AreEqual (-16777216, bmp.GetPixel (32, 0).ToArgb (), "32,0");
 149                                 Assert.AreEqual (-1, bmp.GetPixel (32, 32).ToArgb (), "32,32");
 150                                 Assert.AreEqual (-1, bmp.GetPixel (32, 64).ToArgb (), "32,64");
 151                                 Assert.AreEqual (-16777216, bmp.GetPixel (32, 96).ToArgb (), "32,96");
 152                                 Assert.AreEqual (-1, bmp.GetPixel (32, 128).ToArgb (), "32,128");
 153                                 Assert.AreEqual (-1, bmp.GetPixel (32, 160).ToArgb (), "32,160");
 154                                 Assert.AreEqual (-16777216, bmp.GetPixel (32, 192).ToArgb (), "32,192");
 155                                 Assert.AreEqual (-1, bmp.GetPixel (32, 224).ToArgb (), "32,224");
 156                                 Assert.AreEqual (-16777216, bmp.GetPixel (32, 256).ToArgb (), "32,256");
 157                                 Assert.AreEqual (-16777216, bmp.GetPixel (32, 288).ToArgb (), "32,288");
 158                                 Assert.AreEqual (-1, bmp.GetPixel (32, 320).ToArgb (), "32,320");
 159                                 Assert.AreEqual (-1, bmp.GetPixel (32, 352).ToArgb (), "32,352");
 160                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 0).ToArgb (), "64,0");
 161                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 32).ToArgb (), "64,32");
 162                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 64).ToArgb (), "64,64");
 163                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 96).ToArgb (), "64,96");
 164                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 128).ToArgb (), "64,128");
 165                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 160).ToArgb (), "64,160");
 166                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 192).ToArgb (), "64,192");
 167                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 224).ToArgb (), "64,224");
 168                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 256).ToArgb (), "64,256");
 169                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 288).ToArgb (), "64,288");
 170                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 320).ToArgb (), "64,320");
 171                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 352).ToArgb (), "64,352");
 172                                 Assert.AreEqual (-1, bmp.GetPixel (96, 0).ToArgb (), "96,0");
 173                                 Assert.AreEqual (-16777216, bmp.GetPixel (96, 32).ToArgb (), "96,32");
 174                                 Assert.AreEqual (-16777216, bmp.GetPixel (96, 64).ToArgb (), "96,64");
 175                                 Assert.AreEqual (-16777216, bmp.GetPixel (96, 96).ToArgb (), "96,96");
 176                                 Assert.AreEqual (-16777216, bmp.GetPixel (96, 128).ToArgb (), "96,128");
 177                                 Assert.AreEqual (-16777216, bmp.GetPixel (96, 160).ToArgb (), "96,160");
 178                                 Assert.AreEqual (-1, bmp.GetPixel (96, 192).ToArgb (), "96,192");
 179                                 Assert.AreEqual (-16777216, bmp.GetPixel (96, 224).ToArgb (), "96,224");
 180                                 Assert.AreEqual (-16777216, bmp.GetPixel (96, 256).ToArgb (), "96,256");
 181                                 Assert.AreEqual (-16777216, bmp.GetPixel (96, 288).ToArgb (), "96,288");
 182                                 Assert.AreEqual (-1, bmp.GetPixel (96, 320).ToArgb (), "96,320");
 183                                 Assert.AreEqual (-1, bmp.GetPixel (96, 352).ToArgb (), "96,352");
 184                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 0).ToArgb (), "128,0");
 185                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 32).ToArgb (), "128,32");
 186                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 64).ToArgb (), "128,64");
 187                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 96).ToArgb (), "128,96");
 188                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 128).ToArgb (), "128,128");
 189                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 160).ToArgb (), "128,160");
 190                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 192).ToArgb (), "128,192");
 191                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 224).ToArgb (), "128,224");
 192                                 Assert.AreEqual (-1, bmp.GetPixel (128, 256).ToArgb (), "128,256");
 193                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 288).ToArgb (), "128,288");
 194                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 320).ToArgb (), "128,320");
 195                                 Assert.AreEqual (-16777216, bmp.GetPixel (128, 352).ToArgb (), "128,352");
 196                                 Assert.AreEqual (-1, bmp.GetPixel (160, 0).ToArgb (), "160,0");
 197                                 Assert.AreEqual (-1, bmp.GetPixel (160, 32).ToArgb (), "160,32");
 198                                 Assert.AreEqual (-16777216, bmp.GetPixel (160, 64).ToArgb (), "160,64");
 199                                 Assert.AreEqual (-1, bmp.GetPixel (160, 96).ToArgb (), "160,96");
 200                                 Assert.AreEqual (-16777216, bmp.GetPixel (160, 128).ToArgb (), "160,128");
 201                                 Assert.AreEqual (-1, bmp.GetPixel (160, 160).ToArgb (), "160,160");
 202 #endif
 203                         }
 204                 }
 205
 206                 [Test]
 207                 public void Bitmap1bitData ()
 208                 {
 209                         string sInFile = getInFile ("bitmaps/1bit.png");
 210                         using (Bitmap bmp = new Bitmap (sInFile)) {
 211                                 BitmapData data = bmp.LockBits (new Rectangle (0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
 212                                 try {
 213                                         Assert.AreEqual (bmp.Height, data.Height, "Height");
 214                                         Assert.AreEqual (bmp.Width, data.Width, "Width");
 215                                         Assert.AreEqual (PixelFormat.Format24bppRgb, data.PixelFormat, "PixelFormat");
 216                                         Assert.AreEqual (864, data.Stride, "Stride");
 217                                         int size = data.Height * data.Stride;
 218                                         unsafe {
 219                                                 byte* scan = (byte*) data.Scan0;
 220 #if false
 221                                                 // 1009 is the first prime after 1000 (so we're not affected by a recurring pattern)
 222                                                 for (int p = 0; p < size; p += 1009) {
 223                                                         Console.WriteLine ("\t\t\t\t\t\tAssert.AreEqual ({0}, *(scan + {1}), \"{1}\");", *(scan + p), p);
 224                                                 }
 225 #else
 226                                                 // sampling values from a well known bitmap
 227                                                 Assert.AreEqual (255, *(scan + 0), "0");
 228                                                 Assert.AreEqual (255, *(scan + 1009), "1009");
 229                                                 Assert.AreEqual (255, *(scan + 2018), "2018");
 230                                                 Assert.AreEqual (255, *(scan + 3027), "3027");
 231                                                 Assert.AreEqual (255, *(scan + 4036), "4036");
 232                                                 Assert.AreEqual (255, *(scan + 5045), "5045");
 233                                                 Assert.AreEqual (255, *(scan + 6054), "6054");
 234                                                 Assert.AreEqual (255, *(scan + 7063), "7063");
 235                                                 Assert.AreEqual (255, *(scan + 8072), "8072");
 236                                                 Assert.AreEqual (255, *(scan + 9081), "9081");
 237                                                 Assert.AreEqual (255, *(scan + 10090), "10090");
 238                                                 Assert.AreEqual (0, *(scan + 11099), "11099");
 239                                                 Assert.AreEqual (255, *(scan + 12108), "12108");
 240                                                 Assert.AreEqual (255, *(scan + 13117), "13117");
 241                                                 Assert.AreEqual (0, *(scan + 14126), "14126");
 242                                                 Assert.AreEqual (255, *(scan + 15135), "15135");
 243                                                 Assert.AreEqual (255, *(scan + 16144), "16144");
 244                                                 Assert.AreEqual (0, *(scan + 17153), "17153");
 245                                                 Assert.AreEqual (0, *(scan + 18162), "18162");
 246                                                 Assert.AreEqual (255, *(scan + 19171), "19171");
 247                                                 Assert.AreEqual (0, *(scan + 20180), "20180");
 248                                                 Assert.AreEqual (255, *(scan + 21189), "21189");
 249                                                 Assert.AreEqual (255, *(scan + 22198), "22198");
 250                                                 Assert.AreEqual (0, *(scan + 23207), "23207");
 251                                                 Assert.AreEqual (0, *(scan + 24216), "24216");
 252                                                 Assert.AreEqual (0, *(scan + 25225), "25225");
 253                                                 Assert.AreEqual (0, *(scan + 26234), "26234");
 254                                                 Assert.AreEqual (255, *(scan + 27243), "27243");
 255                                                 Assert.AreEqual (255, *(scan + 28252), "28252");
 256                                                 Assert.AreEqual (0, *(scan + 29261), "29261");
 257                                                 Assert.AreEqual (255, *(scan + 30270), "30270");
 258                                                 Assert.AreEqual (0, *(scan + 31279), "31279");
 259                                                 Assert.AreEqual (0, *(scan + 32288), "32288");
 260                                                 Assert.AreEqual (255, *(scan + 33297), "33297");
 261                                                 Assert.AreEqual (255, *(scan + 34306), "34306");
 262                                                 Assert.AreEqual (255, *(scan + 35315), "35315");
 263                                                 Assert.AreEqual (255, *(scan + 36324), "36324");
 264                                                 Assert.AreEqual (0, *(scan + 37333), "37333");
 265                                                 Assert.AreEqual (255, *(scan + 38342), "38342");
 266                                                 Assert.AreEqual (255, *(scan + 39351), "39351");
 267                                                 Assert.AreEqual (255, *(scan + 40360), "40360");
 268                                                 Assert.AreEqual (255, *(scan + 41369), "41369");
 269                                                 Assert.AreEqual (255, *(scan + 42378), "42378");
 270                                                 Assert.AreEqual (0, *(scan + 43387), "43387");
 271                                                 Assert.AreEqual (0, *(scan + 44396), "44396");
 272                                                 Assert.AreEqual (255, *(scan + 45405), "45405");
 273                                                 Assert.AreEqual (255, *(scan + 46414), "46414");
 274                                                 Assert.AreEqual (255, *(scan + 47423), "47423");
 275                                                 Assert.AreEqual (255, *(scan + 48432), "48432");
 276                                                 Assert.AreEqual (255, *(scan + 49441), "49441");
 277                                                 Assert.AreEqual (0, *(scan + 50450), "50450");
 278                                                 Assert.AreEqual (0, *(scan + 51459), "51459");
 279                                                 Assert.AreEqual (255, *(scan + 52468), "52468");
 280                                                 Assert.AreEqual (255, *(scan + 53477), "53477");
 281                                                 Assert.AreEqual (255, *(scan + 54486), "54486");
 282                                                 Assert.AreEqual (0, *(scan + 55495), "55495");
 283                                                 Assert.AreEqual (0, *(scan + 56504), "56504");
 284                                                 Assert.AreEqual (0, *(scan + 57513), "57513");
 285                                                 Assert.AreEqual (255, *(scan + 58522), "58522");
 286                                                 Assert.AreEqual (255, *(scan + 59531), "59531");
 287                                                 Assert.AreEqual (0, *(scan + 60540), "60540");
 288                                                 Assert.AreEqual (0, *(scan + 61549), "61549");
 289                                                 Assert.AreEqual (0, *(scan + 62558), "62558");
 290                                                 Assert.AreEqual (0, *(scan + 63567), "63567");
 291                                                 Assert.AreEqual (255, *(scan + 64576), "64576");
 292                                                 Assert.AreEqual (0, *(scan + 65585), "65585");
 293                                                 Assert.AreEqual (255, *(scan + 66594), "66594");
 294                                                 Assert.AreEqual (255, *(scan + 67603), "67603");
 295                                                 Assert.AreEqual (0, *(scan + 68612), "68612");
 296                                                 Assert.AreEqual (0, *(scan + 69621), "69621");
 297                                                 Assert.AreEqual (0, *(scan + 70630), "70630");
 298                                                 Assert.AreEqual (0, *(scan + 71639), "71639");
 299                                                 Assert.AreEqual (0, *(scan + 72648), "72648");
 300                                                 Assert.AreEqual (255, *(scan + 73657), "73657");
 301 #endif
 302                                         }
 303                                 }
 304                                 finally {
 305                                         bmp.UnlockBits (data);
 306                                 }
 307                         }
 308                 }
 309
 310                 /* Checks bitmap features on a known 2bbp bitmap */
 311                 [Test]
 312                 public void Bitmap2bitFeatures ()
 313                 {
 314                         if (IsArm64Process ())
 315                                 Assert.Ignore ("https://bugzilla.xamarin.com/show_bug.cgi?id=41171");
 316
 317                         string sInFile = getInFile ("bitmaps/81674-2bpp.png");
 318                         using (Bitmap bmp = new Bitmap (sInFile)) {
 319                                 GraphicsUnit unit = GraphicsUnit.World;
 320                                 RectangleF rect = bmp.GetBounds (ref unit);
 321
 322                                 // quite a promotion! (2 -> 32)
 323                                 Assert.AreEqual (PixelFormat.Format32bppArgb, bmp.PixelFormat);
 324
 325                                 // MS returns a random Flags value (not a good sign)
 326                                 //Assert.AreEqual (0, bmp.Palette.Flags, "Palette.Flags");
 327                                 Assert.AreEqual (0, bmp.Palette.Entries.Length, "Palette.Entries");
 328
 329                                 Assert.AreEqual (100, bmp.Width, "bmp.Width");
 330                                 Assert.AreEqual (100, bmp.Height, "bmp.Height");
 331
 332                                 Assert.AreEqual (0, rect.X, "rect.X");
 333                                 Assert.AreEqual (0, rect.Y, "rect.Y");
 334                                 Assert.AreEqual (100, rect.Width, "rect.Width");
 335                                 Assert.AreEqual (100, rect.Height, "rect.Height");
 336
 337                                 Assert.AreEqual (100, bmp.Size.Width, "bmp.Size.Width");
 338                                 Assert.AreEqual (100, bmp.Size.Height, "bmp.Size.Height");
 339                         }
 340                 }
 341
 342                 [Test]
 343                 public void Bitmap2bitPixels ()
 344                 {
 345                         if (IsArm64Process ())
 346                                 Assert.Ignore ("https://bugzilla.xamarin.com/show_bug.cgi?id=41171");
 347
 348                         string sInFile = getInFile ("bitmaps/81674-2bpp.png");
 349                         using (Bitmap bmp = new Bitmap (sInFile)) {
 350 #if false
 351                                 for (int x = 0; x < bmp.Width; x += 32) {
 352                                         for (int y = 0; y < bmp.Height; y += 32)
 353                                                 Console.WriteLine ("\t\t\t\tAssert.AreEqual ({0}, bmp.GetPixel ({1}, {2}).ToArgb (), \"{1},{2}\");", bmp.GetPixel (x, y).ToArgb (), x, y);
 354                                 }
 355 #else
 356                                 // sampling values from a well known bitmap
 357                                 Assert.AreEqual (-11249559, bmp.GetPixel (0, 0).ToArgb (), "0,0");
 358                                 Assert.AreEqual (-11249559, bmp.GetPixel (0, 32).ToArgb (), "0,32");
 359                                 Assert.AreEqual (-11249559, bmp.GetPixel (0, 64).ToArgb (), "0,64");
 360                                 Assert.AreEqual (-11249559, bmp.GetPixel (0, 96).ToArgb (), "0,96");
 361                                 Assert.AreEqual (-11249559, bmp.GetPixel (32, 0).ToArgb (), "32,0");
 362                                 Assert.AreEqual (-16777216, bmp.GetPixel (32, 32).ToArgb (), "32,32");
 363                                 Assert.AreEqual (-11249559, bmp.GetPixel (32, 64).ToArgb (), "32,64");
 364                                 Assert.AreEqual (-11249559, bmp.GetPixel (32, 96).ToArgb (), "32,96");
 365                                 Assert.AreEqual (-11249559, bmp.GetPixel (64, 0).ToArgb (), "64,0");
 366                                 Assert.AreEqual (-16777216, bmp.GetPixel (64, 32).ToArgb (), "64,32");
 367                                 Assert.AreEqual (-11249559, bmp.GetPixel (64, 64).ToArgb (), "64,64");
 368                                 Assert.AreEqual (-11249559, bmp.GetPixel (64, 96).ToArgb (), "64,96");
 369                                 Assert.AreEqual (-11249559, bmp.GetPixel (96, 0).ToArgb (), "96,0");
 370                                 Assert.AreEqual (-11249559, bmp.GetPixel (96, 32).ToArgb (), "96,32");
 371                                 Assert.AreEqual (-11249559, bmp.GetPixel (96, 64).ToArgb (), "96,64");
 372                                 Assert.AreEqual (-11249559, bmp.GetPixel (96, 96).ToArgb (), "96,96");
 373 #endif
 374                         }
 375                 }
 376
 377                 [Test]
 378                 public void Bitmap2bitData ()
 379                 {
 380                         if (IsArm64Process ())
 381                                 Assert.Ignore ("https://bugzilla.xamarin.com/show_bug.cgi?id=41171");
 382
 383                         string sInFile = getInFile ("bitmaps/81674-2bpp.png");
 384                         using (Bitmap bmp = new Bitmap (sInFile)) {
 385                                 BitmapData data = bmp.LockBits (new Rectangle (0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
 386                                 try {
 387                                         Assert.AreEqual (bmp.Height, data.Height, "Height");
 388                                         Assert.AreEqual (bmp.Width, data.Width, "Width");
 389                                         Assert.AreEqual (PixelFormat.Format24bppRgb, data.PixelFormat, "PixelFormat");
 390                                         Assert.AreEqual (300, data.Stride, "Stride");
 391                                         int size = data.Height * data.Stride;
 392                                         unsafe {
 393                                                 byte* scan = (byte*) data.Scan0;
 394 #if false
 395                                                 // 1009 is the first prime after 1000 (so we're not affected by a recurring pattern)
 396                                                 for (int p = 0; p < size; p += 1009) {
 397                                                         Console.WriteLine ("\t\t\t\t\t\tAssert.AreEqual ({0}, *(scan + {1}), \"{1}\");", *(scan + p), p);
 398                                                 }
 399 #else
 400                                                 // sampling values from a well known bitmap
 401                                                 Assert.AreEqual (105, *(scan + 0), "0");
 402                                                 Assert.AreEqual (88, *(scan + 1009), "1009");
 403                                                 Assert.AreEqual (255, *(scan + 2018), "2018");
 404                                                 Assert.AreEqual (105, *(scan + 3027), "3027");
 405                                                 Assert.AreEqual (88, *(scan + 4036), "4036");
 406                                                 Assert.AreEqual (84, *(scan + 5045), "5045");
 407                                                 Assert.AreEqual (255, *(scan + 6054), "6054");
 408                                                 Assert.AreEqual (88, *(scan + 7063), "7063");
 409                                                 Assert.AreEqual (84, *(scan + 8072), "8072");
 410                                                 Assert.AreEqual (0, *(scan + 9081), "9081");
 411                                                 Assert.AreEqual (0, *(scan + 10090), "10090");
 412                                                 Assert.AreEqual (84, *(scan + 11099), "11099");
 413                                                 Assert.AreEqual (0, *(scan + 12108), "12108");
 414                                                 Assert.AreEqual (88, *(scan + 13117), "13117");
 415                                                 Assert.AreEqual (84, *(scan + 14126), "14126");
 416                                                 Assert.AreEqual (105, *(scan + 15135), "15135");
 417                                                 Assert.AreEqual (88, *(scan + 16144), "16144");
 418                                                 Assert.AreEqual (84, *(scan + 17153), "17153");
 419                                                 Assert.AreEqual (0, *(scan + 18162), "18162");
 420                                                 Assert.AreEqual (88, *(scan + 19171), "19171");
 421                                                 Assert.AreEqual (84, *(scan + 20180), "20180");
 422                                                 Assert.AreEqual (0, *(scan + 21189), "21189");
 423                                                 Assert.AreEqual (88, *(scan + 22198), "22198");
 424                                                 Assert.AreEqual (84, *(scan + 23207), "23207");
 425                                                 Assert.AreEqual (105, *(scan + 24216), "24216");
 426                                                 Assert.AreEqual (88, *(scan + 25225), "25225");
 427                                                 Assert.AreEqual (0, *(scan + 26234), "26234");
 428                                                 Assert.AreEqual (105, *(scan + 27243), "27243");
 429                                                 Assert.AreEqual (88, *(scan + 28252), "28252");
 430                                                 Assert.AreEqual (84, *(scan + 29261), "29261");
 431 #endif
 432                                         }
 433                                 }
 434                                 finally {
 435                                         bmp.UnlockBits (data);
 436                                 }
 437                         }
 438                 }
 439
 440                 /* Checks bitmap features on a known 4bbp bitmap */
 441                 [Test]
 442                 public void Bitmap4bitFeatures ()
 443                 {
 444                         string sInFile = getInFile ("bitmaps/4bit.png");
 445                         using (Bitmap bmp = new Bitmap (sInFile)) {
 446                                 GraphicsUnit unit = GraphicsUnit.World;
 447                                 RectangleF rect = bmp.GetBounds (ref unit);
 448
 449                                 Assert.AreEqual (PixelFormat.Format4bppIndexed, bmp.PixelFormat);
 450
 451                                 Assert.AreEqual (0, bmp.Palette.Flags, "Palette.Flags");
 452                                 Assert.AreEqual (16, bmp.Palette.Entries.Length, "Palette.Entries");
 453                                 Assert.AreEqual (-12106173, bmp.Palette.Entries[0].ToArgb (), "Palette.0");
 454                                 Assert.AreEqual (-10979957, bmp.Palette.Entries[1].ToArgb (), "Palette.1");
 455                                 Assert.AreEqual (-8879241, bmp.Palette.Entries[2].ToArgb (), "Palette.2");
 456                                 Assert.AreEqual (-10381134, bmp.Palette.Entries[3].ToArgb (), "Palette.3");
 457                                 Assert.AreEqual (-7441574, bmp.Palette.Entries[4].ToArgb (), "Palette.4");
 458                                 Assert.AreEqual (-6391673, bmp.Palette.Entries[5].ToArgb (), "Palette.5");
 459                                 Assert.AreEqual (-5861009, bmp.Palette.Entries[6].ToArgb (), "Palette.6");
 460                                 Assert.AreEqual (-3824008, bmp.Palette.Entries[7].ToArgb (), "Palette.7");
 461                                 Assert.AreEqual (-5790569, bmp.Palette.Entries[8].ToArgb (), "Palette.8");
 462                                 Assert.AreEqual (-6178617, bmp.Palette.Entries[9].ToArgb (), "Palette.9");
 463                                 Assert.AreEqual (-4668490, bmp.Palette.Entries[10].ToArgb (), "Palette.10");
 464                                 Assert.AreEqual (-5060143, bmp.Palette.Entries[11].ToArgb (), "Palette.11");
 465                                 Assert.AreEqual (-3492461, bmp.Palette.Entries[12].ToArgb (), "Palette.12");
 466                                 Assert.AreEqual (-2967099, bmp.Palette.Entries[13].ToArgb (), "Palette.13");
 467                                 Assert.AreEqual (-2175574, bmp.Palette.Entries[14].ToArgb (), "Palette.14");
 468                                 Assert.AreEqual (-1314578, bmp.Palette.Entries[15].ToArgb (), "Palette.15");
 469
 470                                 Assert.AreEqual (288, bmp.Width, "bmp.Width");
 471                                 Assert.AreEqual (384, bmp.Height, "bmp.Height");
 472
 473                                 Assert.AreEqual (0, rect.X, "rect.X");
 474                                 Assert.AreEqual (0, rect.Y, "rect.Y");
 475                                 Assert.AreEqual (288, rect.Width, "rect.Width");
 476                                 Assert.AreEqual (384, rect.Height, "rect.Height");
 477
 478                                 Assert.AreEqual (288, bmp.Size.Width, "bmp.Size.Width");
 479                                 Assert.AreEqual (384, bmp.Size.Height, "bmp.Size.Height");
 480                         }
 481                 }
 482
 483                 [Test]
 484                 public void Bitmap4bitPixels ()
 485                 {
 486                         string sInFile = getInFile ("bitmaps/4bit.png");
 487                         using (Bitmap bmp = new Bitmap (sInFile)) {
 488 #if false
 489                                 for (int x = 0; x < bmp.Width; x += 32) {
 490                                         for (int y = 0; y < bmp.Height; y += 32)
 491                                                 Console.WriteLine ("\t\t\t\tAssert.AreEqual ({0}, bmp.GetPixel ({1}, {2}).ToArgb (), \"{1},{2}\");", bmp.GetPixel (x, y).ToArgb (), x, y);
 492                                 }
 493 #else
 494                                 // sampling values from a well known bitmap
 495                                 Assert.AreEqual (-10381134, bmp.GetPixel (0, 0).ToArgb (), "0,0");
 496                                 Assert.AreEqual (-1314578, bmp.GetPixel (0, 32).ToArgb (), "0,32");
 497                                 Assert.AreEqual (-1314578, bmp.GetPixel (0, 64).ToArgb (), "0,64");
 498                                 Assert.AreEqual (-1314578, bmp.GetPixel (0, 96).ToArgb (), "0,96");
 499                                 Assert.AreEqual (-3824008, bmp.GetPixel (0, 128).ToArgb (), "0,128");
 500                                 Assert.AreEqual (-12106173, bmp.GetPixel (0, 160).ToArgb (), "0,160");
 501                                 Assert.AreEqual (-12106173, bmp.GetPixel (0, 192).ToArgb (), "0,192");
 502                                 Assert.AreEqual (-12106173, bmp.GetPixel (0, 224).ToArgb (), "0,224");
 503                                 Assert.AreEqual (-12106173, bmp.GetPixel (0, 256).ToArgb (), "0,256");
 504                                 Assert.AreEqual (-7441574, bmp.GetPixel (0, 288).ToArgb (), "0,288");
 505                                 Assert.AreEqual (-3492461, bmp.GetPixel (0, 320).ToArgb (), "0,320");
 506                                 Assert.AreEqual (-5861009, bmp.GetPixel (0, 352).ToArgb (), "0,352");
 507                                 Assert.AreEqual (-10381134, bmp.GetPixel (32, 0).ToArgb (), "32,0");
 508                                 Assert.AreEqual (-1314578, bmp.GetPixel (32, 32).ToArgb (), "32,32");
 509                                 Assert.AreEqual (-7441574, bmp.GetPixel (32, 64).ToArgb (), "32,64");
 510                                 Assert.AreEqual (-12106173, bmp.GetPixel (32, 96).ToArgb (), "32,96");
 511                                 Assert.AreEqual (-1314578, bmp.GetPixel (32, 128).ToArgb (), "32,128");
 512                                 Assert.AreEqual (-1314578, bmp.GetPixel (32, 160).ToArgb (), "32,160");
 513                                 Assert.AreEqual (-12106173, bmp.GetPixel (32, 192).ToArgb (), "32,192");
 514                                 Assert.AreEqual (-12106173, bmp.GetPixel (32, 224).ToArgb (), "32,224");
 515                                 Assert.AreEqual (-12106173, bmp.GetPixel (32, 256).ToArgb (), "32,256");
 516                                 Assert.AreEqual (-12106173, bmp.GetPixel (32, 288).ToArgb (), "32,288");
 517                                 Assert.AreEqual (-3492461, bmp.GetPixel (32, 320).ToArgb (), "32,320");
 518                                 Assert.AreEqual (-2175574, bmp.GetPixel (32, 352).ToArgb (), "32,352");
 519                                 Assert.AreEqual (-6178617, bmp.GetPixel (64, 0).ToArgb (), "64,0");
 520                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 32).ToArgb (), "64,32");
 521                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 64).ToArgb (), "64,64");
 522                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 96).ToArgb (), "64,96");
 523                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 128).ToArgb (), "64,128");
 524                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 160).ToArgb (), "64,160");
 525                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 192).ToArgb (), "64,192");
 526                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 224).ToArgb (), "64,224");
 527                                 Assert.AreEqual (-5790569, bmp.GetPixel (64, 256).ToArgb (), "64,256");
 528                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 288).ToArgb (), "64,288");
 529                                 Assert.AreEqual (-12106173, bmp.GetPixel (64, 320).ToArgb (), "64,320");
 530                                 Assert.AreEqual (-5790569, bmp.GetPixel (64, 352).ToArgb (), "64,352");
 531                                 Assert.AreEqual (-1314578, bmp.GetPixel (96, 0).ToArgb (), "96,0");
 532                                 Assert.AreEqual (-10381134, bmp.GetPixel (96, 32).ToArgb (), "96,32");
 533                                 Assert.AreEqual (-12106173, bmp.GetPixel (96, 64).ToArgb (), "96,64");
 534                                 Assert.AreEqual (-12106173, bmp.GetPixel (96, 96).ToArgb (), "96,96");
 535                                 Assert.AreEqual (-7441574, bmp.GetPixel (96, 128).ToArgb (), "96,128");
 536                                 Assert.AreEqual (-12106173, bmp.GetPixel (96, 160).ToArgb (), "96,160");
 537                                 Assert.AreEqual (-5790569, bmp.GetPixel (96, 192).ToArgb (), "96,192");
 538                                 Assert.AreEqual (-12106173, bmp.GetPixel (96, 224).ToArgb (), "96,224");
 539                                 Assert.AreEqual (-4668490, bmp.GetPixel (96, 256).ToArgb (), "96,256");
 540                                 Assert.AreEqual (-12106173, bmp.GetPixel (96, 288).ToArgb (), "96,288");
 541                                 Assert.AreEqual (-1314578, bmp.GetPixel (96, 320).ToArgb (), "96,320");
 542                                 Assert.AreEqual (-3492461, bmp.GetPixel (96, 352).ToArgb (), "96,352");
 543                                 Assert.AreEqual (-5861009, bmp.GetPixel (128, 0).ToArgb (), "128,0");
 544                                 Assert.AreEqual (-7441574, bmp.GetPixel (128, 32).ToArgb (), "128,32");
 545                                 Assert.AreEqual (-7441574, bmp.GetPixel (128, 64).ToArgb (), "128,64");
 546                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 96).ToArgb (), "128,96");
 547                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 128).ToArgb (), "128,128");
 548                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 160).ToArgb (), "128,160");
 549                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 192).ToArgb (), "128,192");
 550                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 224).ToArgb (), "128,224");
 551                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 256).ToArgb (), "128,256");
 552                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 288).ToArgb (), "128,288");
 553                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 320).ToArgb (), "128,320");
 554                                 Assert.AreEqual (-12106173, bmp.GetPixel (128, 352).ToArgb (), "128,352");
 555                                 Assert.AreEqual (-1314578, bmp.GetPixel (160, 0).ToArgb (), "160,0");
 556                                 Assert.AreEqual (-1314578, bmp.GetPixel (160, 32).ToArgb (), "160,32");
 557                                 Assert.AreEqual (-12106173, bmp.GetPixel (160, 64).ToArgb (), "160,64");
 558                                 Assert.AreEqual (-1314578, bmp.GetPixel (160, 96).ToArgb (), "160,96");
 559                                 Assert.AreEqual (-12106173, bmp.GetPixel (160, 128).ToArgb (), "160,128");
 560                                 Assert.AreEqual (-5790569, bmp.GetPixel (160, 160).ToArgb (), "160,160");
 561                                 Assert.AreEqual (-12106173, bmp.GetPixel (160, 192).ToArgb (), "160,192");
 562 #endif
 563                         }
 564                 }
 565
 566                 [Test]
 567                 public void Bitmap4bitData ()
 568                 {
 569                         string sInFile = getInFile ("bitmaps/4bit.png");
 570                         using (Bitmap bmp = new Bitmap (sInFile)) {
 571                                 BitmapData data = bmp.LockBits (new Rectangle (0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
 572                                 try {
 573                                         Assert.AreEqual (bmp.Height, data.Height, "Height");
 574                                         Assert.AreEqual (bmp.Width, data.Width, "Width");
 575                                         Assert.AreEqual (PixelFormat.Format24bppRgb, data.PixelFormat, "PixelFormat");
 576                                         Assert.AreEqual (864, data.Stride, "Stride");
 577                                         int size = data.Height * data.Stride;
 578                                         unsafe {
 579                                                 byte* scan = (byte*) data.Scan0;
 580 #if false
 581                                                 // 1009 is the first prime after 1000 (so we're not affected by a recurring pattern)
 582                                                 for (int p = 0; p < size; p += 1009) {
 583                                                         Console.WriteLine ("\t\t\t\t\t\tAssert.AreEqual ({0}, *(scan + {1}), \"{1}\");", *(scan + p), p);
 584                                                 }
 585 #else
 586                                                 // sampling values from a well known bitmap
 587                                                 Assert.AreEqual (178, *(scan + 0), "0");
 588                                                 Assert.AreEqual (184, *(scan + 1009), "1009");
 589                                                 Assert.AreEqual (235, *(scan + 2018), "2018");
 590                                                 Assert.AreEqual (209, *(scan + 3027), "3027");
 591                                                 Assert.AreEqual (240, *(scan + 4036), "4036");
 592                                                 Assert.AreEqual (142, *(scan + 5045), "5045");
 593                                                 Assert.AreEqual (139, *(scan + 6054), "6054");
 594                                                 Assert.AreEqual (152, *(scan + 7063), "7063");
 595                                                 Assert.AreEqual (235, *(scan + 8072), "8072");
 596                                                 Assert.AreEqual (209, *(scan + 9081), "9081");
 597                                                 Assert.AreEqual (240, *(scan + 10090), "10090");
 598                                                 Assert.AreEqual (142, *(scan + 11099), "11099");
 599                                                 Assert.AreEqual (199, *(scan + 12108), "12108");
 600                                                 Assert.AreEqual (201, *(scan + 13117), "13117");
 601                                                 Assert.AreEqual (97, *(scan + 14126), "14126");
 602                                                 Assert.AreEqual (238, *(scan + 15135), "15135");
 603                                                 Assert.AreEqual (240, *(scan + 16144), "16144");
 604                                                 Assert.AreEqual (158, *(scan + 17153), "17153");
 605                                                 Assert.AreEqual (119, *(scan + 18162), "18162");
 606                                                 Assert.AreEqual (201, *(scan + 19171), "19171");
 607                                                 Assert.AreEqual (88, *(scan + 20180), "20180");
 608                                                 Assert.AreEqual (238, *(scan + 21189), "21189");
 609                                                 Assert.AreEqual (240, *(scan + 22198), "22198");
 610                                                 Assert.AreEqual (120, *(scan + 23207), "23207");
 611                                                 Assert.AreEqual (182, *(scan + 24216), "24216");
 612                                                 Assert.AreEqual (70, *(scan + 25225), "25225");
 613                                                 Assert.AreEqual (71, *(scan + 26234), "26234");
 614                                                 Assert.AreEqual (238, *(scan + 27243), "27243");
 615                                                 Assert.AreEqual (240, *(scan + 28252), "28252");
 616                                                 Assert.AreEqual (120, *(scan + 29261), "29261");
 617                                                 Assert.AreEqual (238, *(scan + 30270), "30270");
 618                                                 Assert.AreEqual (70, *(scan + 31279), "31279");
 619                                                 Assert.AreEqual (71, *(scan + 32288), "32288");
 620                                                 Assert.AreEqual (238, *(scan + 33297), "33297");
 621                                                 Assert.AreEqual (240, *(scan + 34306), "34306");
 622                                                 Assert.AreEqual (210, *(scan + 35315), "35315");
 623                                                 Assert.AreEqual (238, *(scan + 36324), "36324");
 624                                                 Assert.AreEqual (70, *(scan + 37333), "37333");
 625                                                 Assert.AreEqual (97, *(scan + 38342), "38342");
 626                                                 Assert.AreEqual (238, *(scan + 39351), "39351");
 627                                                 Assert.AreEqual (240, *(scan + 40360), "40360");
 628                                                 Assert.AreEqual (235, *(scan + 41369), "41369");
 629                                                 Assert.AreEqual (238, *(scan + 42378), "42378");
 630                                                 Assert.AreEqual (117, *(scan + 43387), "43387");
 631                                                 Assert.AreEqual (158, *(scan + 44396), "44396");
 632                                                 Assert.AreEqual (170, *(scan + 45405), "45405");
 633                                                 Assert.AreEqual (240, *(scan + 46414), "46414");
 634                                                 Assert.AreEqual (235, *(scan + 47423), "47423");
 635                                                 Assert.AreEqual (209, *(scan + 48432), "48432");
 636                                                 Assert.AreEqual (120, *(scan + 49441), "49441");
 637                                                 Assert.AreEqual (71, *(scan + 50450), "50450");
 638                                                 Assert.AreEqual (119, *(scan + 51459), "51459");
 639                                                 Assert.AreEqual (240, *(scan + 52468), "52468");
 640                                                 Assert.AreEqual (235, *(scan + 53477), "53477");
 641                                                 Assert.AreEqual (209, *(scan + 54486), "54486");
 642                                                 Assert.AreEqual (70, *(scan + 55495), "55495");
 643                                                 Assert.AreEqual (71, *(scan + 56504), "56504");
 644                                                 Assert.AreEqual (67, *(scan + 57513), "57513");
 645                                                 Assert.AreEqual (240, *(scan + 58522), "58522");
 646                                                 Assert.AreEqual (167, *(scan + 59531), "59531");
 647                                                 Assert.AreEqual (67, *(scan + 60540), "60540");
 648                                                 Assert.AreEqual (70, *(scan + 61549), "61549");
 649                                                 Assert.AreEqual (71, *(scan + 62558), "62558");
 650                                                 Assert.AreEqual (67, *(scan + 63567), "63567");
 651                                                 Assert.AreEqual (240, *(scan + 64576), "64576");
 652                                                 Assert.AreEqual (120, *(scan + 65585), "65585");
 653                                                 Assert.AreEqual (182, *(scan + 66594), "66594");
 654                                                 Assert.AreEqual (70, *(scan + 67603), "67603");
 655                                                 Assert.AreEqual (120, *(scan + 68612), "68612");
 656                                                 Assert.AreEqual (67, *(scan + 69621), "69621");
 657                                                 Assert.AreEqual (70, *(scan + 70630), "70630");
 658                                                 Assert.AreEqual (71, *(scan + 71639), "71639");
 659                                                 Assert.AreEqual (90, *(scan + 72648), "72648");
 660                                                 Assert.AreEqual (240, *(scan + 73657), "73657");
 661 #endif
 662                                         }
 663                                 }
 664                                 finally {
 665                                         bmp.UnlockBits (data);
 666                                 }
 667                         }
 668                 }
 669
 670                 private void Save (PixelFormat original, PixelFormat expected, bool colorCheck)
 671                 {
 672                         string sOutFile = String.Format ("linerect{0}-{1}.png", getOutSufix (), expected.ToString ());
 673
 674                         // Save
 675                         Bitmap bmp = new Bitmap (100, 100, original);
 676                         Graphics gr = Graphics.FromImage (bmp);
 677
 678                         using (Pen p = new Pen (Color.BlueViolet, 2)) {
 679                                 gr.DrawLine (p, 10.0F, 10.0F, 90.0F, 90.0F);
 680                                 gr.DrawRectangle (p, 10.0F, 10.0F, 80.0F, 80.0F);
 681                         }
 682
 683                         try {
 684                                 bmp.Save (sOutFile, ImageFormat.Png);
 685
 686                                 // Load
 687                                 using (Bitmap bmpLoad = new Bitmap (sOutFile)) {
 688                                         Assert.AreEqual (expected, bmpLoad.PixelFormat, "PixelFormat");
 689                                         if (colorCheck) {
 690                                                 Color color = bmpLoad.GetPixel (10, 10);
 691                                                 Assert.AreEqual (Color.FromArgb (255, 138, 43, 226), color, "BlueViolet");
 692                                         }
 693                                 }
 694                         }
 695                         finally {
 696                                 gr.Dispose ();
 697                                 bmp.Dispose ();
 698                                 try {
 699                                         File.Delete (sOutFile);
 700                                 }
 701                                 catch {
 702                                 }
 703                         }
 704                 }
 705
 706                 [Test]
 707                 public void Save_24bppRgb ()
 708                 {
 709                         Save (PixelFormat.Format24bppRgb, PixelFormat.Format24bppRgb, true);
 710                 }
 711
 712                 [Test]
 713                 public void Save_32bppRgb ()
 714                 {
 715                         Save (PixelFormat.Format32bppRgb, PixelFormat.Format32bppArgb, true);
 716                 }
 717
 718                 [Test]
 719                 public void Save_32bppArgb ()
 720                 {
 721                         Save (PixelFormat.Format32bppArgb, PixelFormat.Format32bppArgb, true);
 722                 }
 723
 724                 [Test]
 725                 public void Save_32bppPArgb ()
 726                 {
 727                         Save (PixelFormat.Format32bppPArgb, PixelFormat.Format32bppArgb, true);
 728                 }
 729
 730                 [Test]
 731                 [Category ("NotWorking")]
 732                 public void Save_48bppRgb ()
 733                 {
 734                         Save (PixelFormat.Format48bppRgb, PixelFormat.Format48bppRgb, false);
 735                 }
 736
 737                 [Test]
 738                 [Category ("NotWorking")]
 739                 public void Save_64bppArgb ()
 740                 {
 741                         Save (PixelFormat.Format64bppArgb, PixelFormat.Format64bppArgb, false);
 742                 }
 743
 744                 [Test]
 745                 [Category ("NotWorking")]
 746                 public void Save_64bppPArgb ()
 747                 {
 748                         Save (PixelFormat.Format64bppPArgb, PixelFormat.Format64bppArgb, false);
 749                 }
 750         }
 751 }