[ros-diffs] [akhaldi] 62889: [GDIPLUS_WINETEST] * Sync with Wine 1.7.17. CORE-8080

Author: akhaldi
Date: Tue Apr 22 15:43:03 2014
New Revision: 62889

URL: http://svn.reactos.org/svn/reactos?rev=62889&view=rev
Log:
[GDIPLUS_WINETEST]
* Sync with Wine 1.7.17.
CORE-8080

Modified:
    trunk/rostests/winetests/gdiplus/font.c
    trunk/rostests/winetests/gdiplus/graphics.c
    trunk/rostests/winetests/gdiplus/graphicspath.c
    trunk/rostests/winetests/gdiplus/image.c
    trunk/rostests/winetests/gdiplus/matrix.c
    trunk/rostests/winetests/gdiplus/metafile.c
    trunk/rostests/winetests/gdiplus/region.c

Modified: trunk/rostests/winetests/gdiplus/font.c
URL:
http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdiplus/font.c?…
==============================================================================
--- trunk/rostests/winetests/gdiplus/font.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdiplus/font.c	[iso-8859-1] Tue Apr 22 15:43:03 2014
@@ -742,7 +742,7 @@
     WCHAR ms_shell_dlg[LF_FACESIZE];
     HDC hdc;
     HFONT hfont;
-    LOGFONT lf;
+    LOGFONTA lf;
     GpStatus status;
     GpGraphics *graphics;
     GpFont *font;
@@ -757,9 +757,9 @@
     ok(hfont != 0, "GetStockObject(DEFAULT_GUI_FONT) failed\n");
 
     memset(&lf, 0xfe, sizeof(lf));
-    ret = GetObject(hfont, sizeof(lf), &lf);
+    ret = GetObjectA(hfont, sizeof(lf), &lf);
     ok(ret == sizeof(lf), "GetObject failed\n");
-    ok(!lstrcmp(lf.lfFaceName, "MS Shell Dlg"), "wrong face name
%s\n", lf.lfFaceName);
+    ok(!lstrcmpA(lf.lfFaceName, "MS Shell Dlg"), "wrong face name
%s\n", lf.lfFaceName);
     MultiByteToWideChar(CP_ACP, 0, lf.lfFaceName, -1, ms_shell_dlg, LF_FACESIZE);
 
     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
@@ -767,8 +767,8 @@
     memset(&lf, 0xfe, sizeof(lf));
     status = GdipGetLogFontA(font, graphics, &lf);
     expect(Ok, status);
-    ok(!lstrcmp(lf.lfFaceName, "Microsoft Sans Serif") ||
-       !lstrcmp(lf.lfFaceName, "Tahoma"), "wrong face name %s\n",
lf.lfFaceName);
+    ok(!lstrcmpA(lf.lfFaceName, "Microsoft Sans Serif") ||
+       !lstrcmpA(lf.lfFaceName, "Tahoma"), "wrong face name %s\n",
lf.lfFaceName);
     GdipDeleteFont(font);
 
     status = GdipCreateFontFamilyFromName(ms_shell_dlg, NULL, &family);
@@ -778,21 +778,21 @@
     memset(&lf, 0xfe, sizeof(lf));
     status = GdipGetLogFontA(font, graphics, &lf);
     expect(Ok, status);
-    ok(!lstrcmp(lf.lfFaceName, "Microsoft Sans Serif") ||
-       !lstrcmp(lf.lfFaceName, "Tahoma"), "wrong face name %s\n",
lf.lfFaceName);
+    ok(!lstrcmpA(lf.lfFaceName, "Microsoft Sans Serif") ||
+       !lstrcmpA(lf.lfFaceName, "Tahoma"), "wrong face name %s\n",
lf.lfFaceName);
     GdipDeleteFont(font);
     GdipDeleteFontFamily(family);
 
     status = GdipCreateFontFamilyFromName(nonexistent, NULL, &family);
     ok(status == FontFamilyNotFound, "expected FontFamilyNotFound, got %d\n",
status);
 
-    lstrcpy(lf.lfFaceName, "ThisFontShouldNotExist");
+    lstrcpyA(lf.lfFaceName, "ThisFontShouldNotExist");
     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
     expect(Ok, status);
     memset(&lf, 0xfe, sizeof(lf));
     status = GdipGetLogFontA(font, graphics, &lf);
     expect(Ok, status);
-    ok(!lstrcmp(lf.lfFaceName, "Arial"), "wrong face name %s\n",
lf.lfFaceName);
+    ok(!lstrcmpA(lf.lfFaceName, "Arial"), "wrong face name %s\n",
lf.lfFaceName);
     GdipDeleteFont(font);
 
     /* empty FaceName */
@@ -802,13 +802,13 @@
     memset(&lf, 0xfe, sizeof(lf));
     status = GdipGetLogFontA(font, graphics, &lf);
     expect(Ok, status);
-    ok(!lstrcmp(lf.lfFaceName, "Arial"), "wrong face name %s\n",
lf.lfFaceName);
+    ok(!lstrcmpA(lf.lfFaceName, "Arial"), "wrong face name %s\n",
lf.lfFaceName);
     GdipDeleteFont(font);
 
     /* zeroing out lfWeight and lfCharSet leads to font creation failure */
     lf.lfWeight = 0;
     lf.lfCharSet = 0;
-    lstrcpy(lf.lfFaceName, "ThisFontShouldNotExist");
+    lstrcpyA(lf.lfFaceName, "ThisFontShouldNotExist");
     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);
 todo_wine
     ok(status == NotTrueTypeFont || broken(status == FileNotFound), /* before XP */
@@ -830,7 +830,7 @@
     static const WCHAR string[] = { 'A',0 };
     GpStatus status;
     HDC hdc;
-    LOGFONT lf;
+    LOGFONTA lf;
     GpFont *font;
     GpGraphics *graphics;
     GpMatrix *matrix;
@@ -852,7 +852,7 @@
     expect(Ok, status);
 
     memset(&lf, 0, sizeof(lf));
-    lstrcpy(lf.lfFaceName, "Tahoma");
+    lstrcpyA(lf.lfFaceName, "Tahoma");
     lf.lfHeight = -100;
     lf.lfWidth = 100;
     status = GdipCreateFontFromLogfontA(hdc, &lf, &font);

Modified: trunk/rostests/winetests/gdiplus/graphics.c
URL:
http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdiplus/graphic…
==============================================================================
--- trunk/rostests/winetests/gdiplus/graphics.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdiplus/graphics.c	[iso-8859-1] Tue Apr 22 15:43:03 2014
@@ -20,7 +20,6 @@
  */
 
 #include <math.h>
-#include <assert.h>
 
 #define WIN32_NO_STATUS
 #define _INC_WINDOWS
@@ -66,7 +65,7 @@
     case UnitMillimeter:
         return units * dpi / mm_per_inch;
     default:
-        assert(0);
+        ok(0, "Unsupported unit: %d\n", unit);
         return 0;
     }
 }
@@ -88,7 +87,7 @@
     case UnitMillimeter:
         return pixels * mm_per_inch / dpi;
     default:
-        assert(0);
+        ok(0, "Unsupported unit: %d\n", unit);
         return 0;
     }
 }
@@ -5502,6 +5501,52 @@
     DeleteDC(hdc);
 }
 
+
+static void test_GdipFillRectangles(void)
+{
+    GpStatus status;
+    GpGraphics *graphics = NULL;
+    GpBrush *brush = NULL;
+    HDC hdc = GetDC( hwnd );
+    GpRectF rects[2] = {{0,0,10,10}, {10,10,10,10}};
+
+    ok(hdc != NULL, "Expected HDC to be initialized\n");
+
+    status = GdipCreateFromHDC(hdc, &graphics);
+    expect(Ok, status);
+    ok(graphics != NULL, "Expected graphics to be initialized\n");
+
+    status = GdipCreateSolidFill((ARGB)0xffff00ff, (GpSolidFill**)&brush);
+    expect(Ok, status);
+    ok(brush != NULL, "Expected brush to be initialized\n");
+
+    status = GdipFillRectangles(NULL, brush, rects, 2);
+    expect(InvalidParameter, status);
+
+    status = GdipFillRectangles(graphics, NULL, rects, 2);
+    expect(InvalidParameter, status);
+
+    status = GdipFillRectangles(graphics, brush, NULL, 2);
+    expect(InvalidParameter, status);
+
+    status = GdipFillRectangles(graphics, brush, rects, 0);
+    expect(InvalidParameter, status);
+
+    status = GdipFillRectangles(graphics, brush, rects, -1);
+    expect(InvalidParameter, status);
+
+    status = GdipFillRectangles(graphics, brush, rects, 1);
+    expect(Ok, status);
+
+    status = GdipFillRectangles(graphics, brush, rects, 2);
+    expect(Ok, status);
+
+    GdipDeleteBrush(brush);
+    GdipDeleteGraphics(graphics);
+
+    ReleaseDC(hwnd, hdc);
+}
+
 START_TEST(graphics)
 {
     struct GdiplusStartupInput gdiplusStartupInput;
@@ -5513,8 +5558,8 @@
     class.style = CS_HREDRAW | CS_VREDRAW;
     class.lpfnWndProc = DefWindowProcA;
     class.hInstance = GetModuleHandleA(0);
-    class.hIcon = LoadIcon(0, IDI_APPLICATION);
-    class.hCursor = LoadCursor(NULL, IDC_ARROW);
+    class.hIcon = LoadIconA(0, (LPCSTR)IDI_APPLICATION);
+    class.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
     class.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
     RegisterClassA( &class );
     hwnd = CreateWindowA( "gdiplus_test", "graphics test",
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
@@ -5574,6 +5619,7 @@
     test_getdc_scaled();
     test_alpha_hdc();
     test_bitmapfromgraphics();
+    test_GdipFillRectangles();
 
     GdiplusShutdown(gdiplusToken);
     DestroyWindow( hwnd );

Modified: trunk/rostests/winetests/gdiplus/graphicspath.c
URL:
http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdiplus/graphic…
==============================================================================
--- trunk/rostests/winetests/gdiplus/graphicspath.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdiplus/graphicspath.c	[iso-8859-1] Tue Apr 22 15:43:03 2014
@@ -162,15 +162,16 @@
     GpStatus status;
     INT count;
 
-    GdipCreatePath(FillModeAlternate, &path);
+    status = GdipCreatePath(FillModeAlternate, &path);
+    expect(Ok, status);
     status = GdipAddPathLine(path, 5.0, 5.0, 100.0, 50.0);
     expect(Ok, status);
 
-    /* Prepare storage. Made by wrapper class. */
     status = GdipGetPointCount(path, &count);
     expect(Ok, status);
-
-    data.Count  = 2;
+    expect(2, count);
+
+    data.Count  = count;
     data.Types  = GdipAlloc(sizeof(BYTE) * count);
     data.Points = GdipAlloc(sizeof(PointF) * count);
 

Modified: trunk/rostests/winetests/gdiplus/image.c
URL:
http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdiplus/image.c…
==============================================================================
--- trunk/rostests/winetests/gdiplus/image.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdiplus/image.c	[iso-8859-1] Tue Apr 22 15:43:03 2014
@@ -3221,8 +3221,10 @@
         ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i,
td[i].id, prop_item->id);
         prop_size -= sizeof(*prop_item);
         ok(prop_item->length == prop_size, "%u: expected length %u, got
%u\n", i, prop_size, prop_item->length);
-        ok(td[i].length == prop_item->length, "%u: expected length %u, got
%u\n", i, td[i].length, prop_item->length);
-        ok(td[i].length == prop_size, "%u: expected length %u, got %u\n", i,
td[i].length, prop_size);
+        ok(td[i].length == prop_item->length || broken(td[i].id == 0xf00f &&
td[i].length == prop_item->length+1) /* XP */,
+           "%u: expected length %u, got %u\n", i, td[i].length,
prop_item->length);
+        ok(td[i].length == prop_size || broken(td[i].id == 0xf00f && td[i].length
== prop_size+1) /* XP */,
+           "%u: expected length %u, got %u\n", i, td[i].length, prop_size);
         if (td[i].length == prop_item->length)
         {
             int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
@@ -3231,10 +3233,10 @@
             {
                 UINT j;
                 BYTE *data = prop_item->value;
-                printf("id %#x:", prop_item->id);
+                trace("id %#x:", prop_item->id);
                 for (j = 0; j < prop_item->length; j++)
-                    printf(" %02x", data[j]);
-                printf("\n");
+                    trace(" %02x", data[j]);
+                trace("\n");
             }
         }
         HeapFree(GetProcessHeap(), 0, prop_item);
@@ -3337,10 +3339,10 @@
             {
                 UINT j;
                 BYTE *data = prop_item->value;
-                printf("id %#x:", prop_item->id);
+                trace("id %#x:", prop_item->id);
                 for (j = 0; j < prop_item->length; j++)
-                    printf(" %02x", data[j]);
-                printf("\n");
+                    trace(" %02x", data[j]);
+                trace("\n");
             }
         }
         HeapFree(GetProcessHeap(), 0, prop_item);
@@ -3399,10 +3401,10 @@
             {
                 UINT j;
                 BYTE *data = prop_item[i].value;
-                printf("id %#x:", prop_item[i].id);
+                trace("id %#x:", prop_item[i].id);
                 for (j = 0; j < prop_item[i].length; j++)
-                    printf(" %02x", data[j]);
-                printf("\n");
+                    trace(" %02x", data[j]);
+                trace("\n");
             }
         }
         item_data += prop_item[i].length;
@@ -3631,10 +3633,10 @@
                 if (!match)
                 {
                     BYTE *bits = data.Scan0;
-                    printf("%u: data mismatch for format %#x:", i,
td[i].format);
+                    trace("%u: data mismatch for format %#x:", i,
td[i].format);
                     for (j = 0; j < td[i].size; j++)
-                        printf(" %02x", bits[j]);
-                    printf("\n");
+                        trace(" %02x", bits[j]);
+                    trace("\n");
                 }
             }
             else
@@ -3662,10 +3664,10 @@
             {
                 UINT j;
                 BYTE *bits = data.Scan0;
-                printf("%u: data mismatch for format %#x:", i, td[i].format);
+                trace("%u: data mismatch for format %#x:", i, td[i].format);
                 for (j = 0; j < 48; j++)
-                    printf(" %02x", bits[j]);
-                printf("\n");
+                    trace(" %02x", bits[j]);
+                trace("\n");
             }
         }
 
@@ -3717,8 +3719,8 @@
         UINT i, size = sizeof(white_2x2);
         BYTE *bits = white_2x2;
         for (i = 0; i < size; i++)
-            printf(" %02x", bits[i]);
-        printf("\n");
+            trace(" %02x", bits[i]);
+        trace("\n");
     }
 
     status = GdipDeleteGraphics(graphics);
@@ -3769,8 +3771,8 @@
         UINT i, size = sizeof(white_2x2);
         BYTE *bits = white_2x2;
         for (i = 0; i < size; i++)
-            printf(" %02x", bits[i]);
-        printf("\n");
+            trace(" %02x", bits[i]);
+        trace("\n");
     }
 
     status = GdipDeleteGraphics(graphics);
@@ -3817,7 +3819,7 @@
         else
         {
             expect(Ok, status);
-            ret = GetObject(hbitmap, sizeof(bm), &bm);
+            ret = GetObjectW(hbitmap, sizeof(bm), &bm);
             expect(sizeof(bm), ret);
             expect(0, bm.bmType);
             expect(1, bm.bmWidth);
@@ -3976,8 +3978,8 @@
             UINT i, size = sizeof(dst_8x1);
             const BYTE *bits = dst_8x1;
             for (i = 0; i < size; i++)
-                printf(" %02x", bits[i]);
-            printf("\n");
+                trace(" %02x", bits[i]);
+            trace("\n");
         }
     }
 
@@ -4102,10 +4104,10 @@
             {
                 UINT j;
                 BYTE *data = prop_item->value;
-                printf("id %#x:", prop_item->id);
+                trace("id %#x:", prop_item->id);
                 for (j = 0; j < prop_item->length; j++)
-                    printf(" %02x", data[j]);
-                printf("\n");
+                    trace(" %02x", data[j]);
+                trace("\n");
             }
         }
         HeapFree(GetProcessHeap(), 0, prop_item);
@@ -4164,10 +4166,10 @@
             {
                 UINT j;
                 BYTE *data = prop_item[i].value;
-                printf("id %#x:", prop_item[i].id);
+                trace("id %#x:", prop_item[i].id);
                 for (j = 0; j < prop_item[i].length; j++)
-                    printf(" %02x", data[j]);
-                printf("\n");
+                    trace(" %02x", data[j]);
+                trace("\n");
             }
         }
         item_data += prop_item[i].length;
@@ -4248,6 +4250,32 @@
     GdipDisposeImage((GpImage *)bitmap);
 }
 
+
+static void test_CloneBitmapArea(void)
+{
+    GpStatus status;
+    GpBitmap *bitmap, *copy;
+    BitmapData data, data2;
+
+    status = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat24bppRGB, NULL, &bitmap);
+    expect(Ok, status);
+
+    status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead | ImageLockModeWrite,
PixelFormat24bppRGB, &data);
+    expect(Ok, status);
+
+    status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB,
&data2);
+    expect(WrongState, status);
+
+    status = GdipCloneBitmapAreaI(0, 0, 1, 1, PixelFormat24bppRGB, bitmap, &copy);
+    expect(Ok, status);
+
+    status = GdipBitmapUnlockBits(bitmap, &data);
+    expect(Ok, status);
+
+    GdipDisposeImage((GpImage *)copy);
+    GdipDisposeImage((GpImage *)bitmap);
+}
+
 START_TEST(image)
 {
     struct GdiplusStartupInput gdiplusStartupInput;
@@ -4260,6 +4288,7 @@
 
     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 
+    test_CloneBitmapArea();
     test_ARGB_conversion();
     test_DrawImage_scale();
     test_image_format();

Modified: trunk/rostests/winetests/gdiplus/matrix.c
URL:
http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdiplus/matrix.…
==============================================================================
--- trunk/rostests/winetests/gdiplus/matrix.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdiplus/matrix.c	[iso-8859-1] Tue Apr 22 15:43:03 2014
@@ -83,6 +83,9 @@
 
     GdipCreateMatrix2(1.0, -2.0, 30.0, 40.0, -500.0, 600.0, &matrix);
 
+    status = GdipTransformMatrixPoints(matrix, pts, 0);
+    expect(InvalidParameter, status);
+
     status = GdipTransformMatrixPoints(matrix, pts, 10);
     expect(Ok, status);
 

Modified: trunk/rostests/winetests/gdiplus/metafile.c
URL:
http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdiplus/metafil…
==============================================================================
--- trunk/rostests/winetests/gdiplus/metafile.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdiplus/metafile.c	[iso-8859-1] Tue Apr 22 15:43:03 2014
@@ -22,19 +22,23 @@
 #define _INC_WINDOWS
 #define COM_NO_WINDOWS_H
 
-//#include "windows.h"
+#include <math.h>
+
 #include <wine/test.h>
 #include <wingdi.h>
 #include <objbase.h>
 #include <gdiplus.h>
 
 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n",
expected, got)
+#define expectf(expected, got) ok(fabs((expected) - (got)) < 0.0001, "Expected
%f, got %f\n", (expected), (got))
+
+static BOOL save_metafiles;
 
 typedef struct emfplus_record
 {
-    ULONG todo;
+    BOOL  todo;
     ULONG record_type;
-    ULONG playback_todo;
+    BOOL  playback_todo;
 } emfplus_record;
 
 typedef struct emfplus_check_state
@@ -94,7 +98,7 @@
 
                 if (state->expected[state->count].record_type)
                 {
-                    actual.todo = 0;
+                    actual.todo = FALSE;
                     actual.record_type = record->Type;
 
                     check_record(state->count, state->desc,
&state->expected[state->count], &actual);
@@ -117,7 +121,7 @@
 
     if (state->expected[state->count].record_type)
     {
-        actual.todo = 0;
+        actual.todo = FALSE;
         actual.record_type = lpEMFR->iType;
 
         check_record(state->count, state->desc,
&state->expected[state->count], &actual);
@@ -154,7 +158,7 @@
     emfplus_check_state *state = (emfplus_check_state*)userdata;
     emfplus_record actual;
 
-    actual.todo = 0;
+    actual.todo = FALSE;
     actual.record_type = record_type;
 
     if (dataSize == 0)
@@ -249,6 +253,29 @@
     stat = GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, dst_points,
         3, src_rect, src_unit, play_metafile_proc, &state, NULL);
     expect(Ok, stat);
+}
+
+static void save_metafile(GpMetafile *metafile, const char *filename)
+{
+    if (save_metafiles)
+    {
+        GpMetafile *clone;
+        HENHMETAFILE hemf;
+        GpStatus stat;
+
+        stat = GdipCloneImage((GpImage*)metafile, (GpImage**)&clone);
+        expect(Ok, stat);
+
+        stat = GdipGetHemfFromMetafile(clone, &hemf);
+        expect(Ok, stat);
+
+        DeleteEnhMetaFile(CopyEnhMetaFileA(hemf, filename));
+
+        DeleteEnhMetaFile(hemf);
+
+        stat = GdipDisposeImage((GpImage*)clone);
+        expect(Ok, stat);
+    }
 }
 
 static const emfplus_record empty_records[] = {
@@ -312,6 +339,8 @@
     expect(Ok, stat);
 
     check_metafile(metafile, empty_records, "empty metafile", dst_points,
&frame, UnitPixel);
+
+    save_metafile(metafile, "empty.emf");
 
     stat = GdipGetHemfFromMetafile(metafile, &hemf);
     expect(Ok, stat);
@@ -402,6 +431,8 @@
 
     check_metafile(metafile, getdc_records, "getdc metafile", dst_points,
&frame, UnitPixel);
 
+    save_metafile(metafile, "getdc.emf");
+
     stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL,
&bitmap);
     expect(Ok, stat);
 
@@ -535,6 +566,8 @@
 
     check_metafile(metafile, emfonly_records, "emfonly metafile", dst_points,
&frame, UnitPixel);
 
+    save_metafile(metafile, "emfonly.emf");
+
     stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL,
&bitmap);
     expect(Ok, stat);
 
@@ -607,10 +640,323 @@
     ok(ret != 0, "Failed to delete enhmetafile %p\n", hemf);
 }
 
+static const emfplus_record fillrect_records[] = {
+    {0, EMR_HEADER},
+    {0, EmfPlusRecordTypeHeader},
+    {0, EmfPlusRecordTypeFillRects},
+    {0, EmfPlusRecordTypeEndOfFile},
+    {0, EMR_EOF},
+    {0}
+};
+
+static void test_fillrect(void)
+{
+    GpStatus stat;
+    GpMetafile *metafile;
+    GpGraphics *graphics;
+    HDC hdc;
+    HENHMETAFILE hemf;
+    static const GpRectF frame = {0.0, 0.0, 100.0, 100.0};
+    static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
+    static const GpPointF dst_points_half[3] = {{0.0,0.0},{50.0,0.0},{0.0,50.0}};
+    static const WCHAR description[] =
{'w','i','n','e','t','e','s','t',0};
+    GpBitmap *bitmap;
+    ARGB color;
+    GpBrush *brush;
+
+    hdc = CreateCompatibleDC(0);
+
+    stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame,
MetafileFrameUnitPixel, description, &metafile);
+    expect(Ok, stat);
+
+    DeleteDC(hdc);
+
+    if (stat != Ok)
+        return;
+
+    stat = GdipGetHemfFromMetafile(metafile, &hemf);
+    expect(InvalidParameter, stat);
+
+    stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
+    expect(Ok, stat);
+
+    stat = GdipCreateSolidFill((ARGB)0xff0000ff, (GpSolidFill**)&brush);
+    expect(Ok, stat);
+
+    stat = GdipFillRectangleI(graphics, brush, 25, 25, 75, 75);
+    expect(Ok, stat);
+
+    stat = GdipDeleteBrush(brush);
+    expect(Ok, stat);
+
+    stat = GdipDeleteGraphics(graphics);
+    expect(Ok, stat);
+
+    check_metafile(metafile, fillrect_records, "fillrect metafile", dst_points,
&frame, UnitPixel);
+
+    save_metafile(metafile, "fillrect.emf");
+
+    stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL,
&bitmap);
+    expect(Ok, stat);
+
+    stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
+    expect(Ok, stat);
+
+    play_metafile(metafile, graphics, fillrect_records, "fillrect playback",
dst_points, &frame, UnitPixel);
+
+    stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
+    expect(Ok, stat);
+    expect(0, color);
+
+    stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
+    expect(Ok, stat);
+    expect(0xff0000ff, color);
+
+    stat = GdipBitmapSetPixel(bitmap, 50, 50, 0);
+    expect(Ok, stat);
+
+    play_metafile(metafile, graphics, fillrect_records, "fillrect playback",
dst_points_half, &frame, UnitPixel);
+
+    stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
+    expect(Ok, stat);
+    expect(0xff0000ff, color);
+
+    stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
+    expect(Ok, stat);
+    expect(0, color);
+
+    stat = GdipBitmapSetPixel(bitmap, 15, 15, 0);
+    expect(Ok, stat);
+
+    stat = GdipDrawImagePointsRect(graphics, (GpImage*)metafile, dst_points, 3,
+        0.0, 0.0, 100.0, 100.0, UnitPixel, NULL, NULL, NULL);
+    expect(Ok, stat);
+
+    stat = GdipBitmapGetPixel(bitmap, 15, 15, &color);
+    expect(Ok, stat);
+    expect(0, color);
+
+    stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
+    expect(Ok, stat);
+    expect(0xff0000ff, color);
+
+    stat = GdipDeleteGraphics(graphics);
+    expect(Ok, stat);
+
+    stat = GdipDisposeImage((GpImage*)bitmap);
+    expect(Ok, stat);
+
+    stat = GdipDisposeImage((GpImage*)metafile);
+    expect(Ok, stat);
+}
+
+static const emfplus_record pagetransform_records[] = {
+    {0, EMR_HEADER},
+    {0, EmfPlusRecordTypeHeader},
+    {0, EmfPlusRecordTypeFillRects},
+    {0, EmfPlusRecordTypeSetPageTransform},
+    {0, EmfPlusRecordTypeFillRects},
+    {0, EmfPlusRecordTypeSetPageTransform},
+    {0, EmfPlusRecordTypeFillRects},
+    {0, EmfPlusRecordTypeSetPageTransform},
+    {0, EmfPlusRecordTypeFillRects},
+    {0, EmfPlusRecordTypeSetPageTransform},
+    {0, EmfPlusRecordTypeFillRects},
+    {0, EmfPlusRecordTypeEndOfFile},
+    {0, EMR_EOF},
+    {0}
+};
+
+static void test_pagetransform(void)
+{
+    GpStatus stat;
+    GpMetafile *metafile;
+    GpGraphics *graphics;
+    HDC hdc;
+    static const GpRectF frame = {0.0, 0.0, 5.0, 5.0};
+    static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
+    static const WCHAR description[] =
{'w','i','n','e','t','e','s','t',0};
+    GpBitmap *bitmap;
+    ARGB color;
+    GpBrush *brush;
+    GpUnit unit;
+    REAL scale, dpix, dpiy;
+    UINT width, height;
+
+    hdc = CreateCompatibleDC(0);
+
+    stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitInch,
description, &metafile);
+    expect(Ok, stat);
+
+    DeleteDC(hdc);
+
+    if (stat != Ok)
+        return;
+
+    stat = GdipGetImageHorizontalResolution((GpImage*)metafile, &dpix);
+    todo_wine expect(InvalidParameter, stat);
+
+    stat = GdipGetImageVerticalResolution((GpImage*)metafile, &dpiy);
+    todo_wine expect(InvalidParameter, stat);
+
+    stat = GdipGetImageWidth((GpImage*)metafile, &width);
+    todo_wine expect(InvalidParameter, stat);
+
+    stat = GdipGetImageHeight((GpImage*)metafile, &height);
+    todo_wine expect(InvalidParameter, stat);
+
+    stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
+    expect(Ok, stat);
+
+    /* initial scale */
+    stat = GdipGetPageUnit(graphics, &unit);
+    expect(Ok, stat);
+    expect(UnitDisplay, unit);
+
+    stat = GdipGetPageScale(graphics, &scale);
+    expect(Ok, stat);
+    expectf(1.0, scale);
+
+    stat = GdipGetDpiX(graphics, &dpix);
+    expect(Ok, stat);
+    expectf(96.0, dpix);
+
+    stat = GdipGetDpiY(graphics, &dpiy);
+    expect(Ok, stat);
+    expectf(96.0, dpiy);
+
+    stat = GdipCreateSolidFill((ARGB)0xff0000ff, (GpSolidFill**)&brush);
+    expect(Ok, stat);
+
+    stat = GdipFillRectangleI(graphics, brush, 1, 2, 1, 1);
+    expect(Ok, stat);
+
+    stat = GdipDeleteBrush(brush);
+    expect(Ok, stat);
+
+    /* page unit = pixels */
+    stat = GdipSetPageUnit(graphics, UnitPixel);
+    expect(Ok, stat);
+
+    stat = GdipGetPageUnit(graphics, &unit);
+    expect(Ok, stat);
+    expect(UnitPixel, unit);
+
+    stat = GdipCreateSolidFill((ARGB)0xff00ff00, (GpSolidFill**)&brush);
+    expect(Ok, stat);
+
+    stat = GdipFillRectangleI(graphics, brush, 0, 1, 1, 1);
+    expect(Ok, stat);
+
+    stat = GdipDeleteBrush(brush);
+    expect(Ok, stat);
+
+    /* page scale = 3, unit = pixels */
+    stat = GdipSetPageScale(graphics, 3.0);
+    expect(Ok, stat);
+
+    stat = GdipGetPageScale(graphics, &scale);
+    expect(Ok, stat);
+    expectf(3.0, scale);
+
+    stat = GdipCreateSolidFill((ARGB)0xff00ffff, (GpSolidFill**)&brush);
+    expect(Ok, stat);
+
+    stat = GdipFillRectangleI(graphics, brush, 0, 1, 2, 2);
+    expect(Ok, stat);
+
+    stat = GdipDeleteBrush(brush);
+    expect(Ok, stat);
+
+    /* page scale = 3, unit = inches */
+    stat = GdipSetPageUnit(graphics, UnitInch);
+    expect(Ok, stat);
+
+    stat = GdipGetPageUnit(graphics, &unit);
+    expect(Ok, stat);
+    expect(UnitInch, unit);
+
+    stat = GdipCreateSolidFill((ARGB)0xffff0000, (GpSolidFill**)&brush);
+    expect(Ok, stat);
+
+    stat = GdipFillRectangle(graphics, brush, 1.0/96.0, 0, 1, 1);
+    expect(Ok, stat);
+
+    stat = GdipDeleteBrush(brush);
+    expect(Ok, stat);
+
+    /* page scale = 3, unit = display */
+    stat = GdipSetPageUnit(graphics, UnitDisplay);
+    expect(Ok, stat);
+
+    stat = GdipGetPageUnit(graphics, &unit);
+    expect(Ok, stat);
+    expect(UnitDisplay, unit);
+
+    stat = GdipCreateSolidFill((ARGB)0xffff00ff, (GpSolidFill**)&brush);
+    expect(Ok, stat);
+
+    stat = GdipFillRectangle(graphics, brush, 3, 3, 2, 2);
+    expect(Ok, stat);
+
+    stat = GdipDeleteBrush(brush);
+    expect(Ok, stat);
+
+    stat = GdipDeleteGraphics(graphics);
+    expect(Ok, stat);
+
+    check_metafile(metafile, pagetransform_records, "pagetransform metafile",
dst_points, &frame, UnitPixel);
+
+    save_metafile(metafile, "pagetransform.emf");
+
+    stat = GdipCreateBitmapFromScan0(100, 100, 0, PixelFormat32bppARGB, NULL,
&bitmap);
+    expect(Ok, stat);
+
+    stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
+    expect(Ok, stat);
+
+    play_metafile(metafile, graphics, pagetransform_records, "pagetransform
playback", dst_points, &frame, UnitPixel);
+
+    stat = GdipBitmapGetPixel(bitmap, 50, 50, &color);
+    expect(Ok, stat);
+    expect(0, color);
+
+    stat = GdipBitmapGetPixel(bitmap, 30, 50, &color);
+    expect(Ok, stat);
+    expect(0xff0000ff, color);
+
+    stat = GdipBitmapGetPixel(bitmap, 10, 30, &color);
+    expect(Ok, stat);
+    expect(0xff00ff00, color);
+
+    stat = GdipBitmapGetPixel(bitmap, 20, 80, &color);
+    expect(Ok, stat);
+    expect(0xff00ffff, color);
+
+    stat = GdipBitmapGetPixel(bitmap, 80, 20, &color);
+    expect(Ok, stat);
+    expect(0xffff0000, color);
+
+    stat = GdipBitmapGetPixel(bitmap, 80, 80, &color);
+    expect(Ok, stat);
+    expect(0xffff00ff, color);
+
+    stat = GdipDeleteGraphics(graphics);
+    expect(Ok, stat);
+
+    stat = GdipDisposeImage((GpImage*)bitmap);
+    expect(Ok, stat);
+
+    stat = GdipDisposeImage((GpImage*)metafile);
+    expect(Ok, stat);
+}
+
 START_TEST(metafile)
 {
     struct GdiplusStartupInput gdiplusStartupInput;
     ULONG_PTR gdiplusToken;
+    int myARGC;
+    char **myARGV;
 
     gdiplusStartupInput.GdiplusVersion              = 1;
     gdiplusStartupInput.DebugEventCallback          = NULL;
@@ -619,9 +965,16 @@
 
     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 
+    myARGC = winetest_get_mainargs( &myARGV );
+
+    if (myARGC >= 3 && !strcmp(myARGV[2], "save"))
+        save_metafiles = TRUE;
+
     test_empty();
     test_getdc();
     test_emfonly();
+    test_fillrect();
+    test_pagetransform();
 
     GdiplusShutdown(gdiplusToken);
 }

Modified: trunk/rostests/winetests/gdiplus/region.c
URL:
http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdiplus/region.…
==============================================================================
--- trunk/rostests/winetests/gdiplus/region.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdiplus/region.c	[iso-8859-1] Tue Apr 22 15:43:03 2014
@@ -2,6 +2,7 @@
  * Unit test suite for gdiplus regions
  *
  * Copyright (C) 2008 Huw Davies
+ * Copyright (C) 2013 Dmitry Timoshkov
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -37,20 +38,13 @@
 #define RGNDATA_MAGIC           0xdbc01001
 #define RGNDATA_MAGIC2          0xdbc01002
 
-#define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n",
expected, got)
-
-#define expectf_(expected, got, precision) ok(fabs(expected - got) < precision,
"Expected %.2f, got %.2f\n", expected, got)
-#define expectf(expected, got) expectf_(expected, got, 0.0001)
-
-#define expect_magic(value) ok(*value == RGNDATA_MAGIC || *value == RGNDATA_MAGIC2,
"Expected a known magic value, got %8x\n", *value)
-
-#define expect_dword(value, expected) ok(*(value) == expected, "expected %08x got
%08x\n", expected, *(value))
-
-static inline void expect_float(DWORD *value, FLOAT expected)
-{
-    FLOAT valuef = *(FLOAT*)value;
-    ok(valuef == expected, "expected %f got %f\n", expected, valuef);
-}
+#define expect(expected, got) ok((got) == (expected), "Expected %.8x, got
%.8x\n", (expected), (got))
+#define expectf_(expected, got, precision) ok(fabs((expected) - (got)) < (precision),
"Expected %f, got %f\n", (expected), (got))
+#define expectf(expected, got) expectf_((expected), (got), 0.001)
+
+#define expect_magic(value) ok(*(value) == RGNDATA_MAGIC || *(value) == RGNDATA_MAGIC2,
"Expected a known magic value, got %8x\n", *(value))
+#define expect_dword(value, expected) expect((expected), *(value))
+#define expect_float(value, expected) expectf((expected), *(FLOAT *)(value))
 
 /* We get shorts back, not INTs like a GpPoint */
 typedef struct RegionDataPoint
@@ -91,7 +85,9 @@
     {
         rect = (const RECT *)rgn.data.Buffer;
         trace("rect (%d,%d-%d,%d)\n", rect->left, rect->top,
rect->right, rect->bottom);
-        ok(EqualRect(rect, rc), "rects don't match\n");
+        ok(EqualRect(rect, rc), "expected (%d,%d)-(%d,%d), got
(%d,%d)-(%d,%d)\n",
+           rc->left, rc->top, rc->right, rc->bottom,
+           rect->left, rect->top, rect->right, rect->bottom);
     }
 
     ok(rgn.data.rdh.dwSize == sizeof(rgn.data.rdh), "expected sizeof(rdh), got
%u\n", rgn.data.rdh.dwSize);
@@ -106,7 +102,9 @@
         ok(rgn.data.rdh.nCount == 1, "expected 1, got %u\n",
rgn.data.rdh.nCount);
         ok(rgn.data.rdh.nRgnSize == sizeof(RECT),  "expected sizeof(RECT), got
%u\n", rgn.data.rdh.nRgnSize);
     }
-    ok(EqualRect(&rgn.data.rdh.rcBound, rc), "rects don't match\n");
+    ok(EqualRect(&rgn.data.rdh.rcBound, rc), "expected (%d,%d)-(%d,%d), got
(%d,%d)-(%d,%d)\n",
+       rc->left, rc->top, rc->right, rc->bottom,
+       rgn.data.rdh.rcBound.left, rgn.data.rdh.rcBound.top, rgn.data.rdh.rcBound.right,
rgn.data.rdh.rcBound.bottom);
 }
 
 static void test_getregiondata(void)
@@ -115,54 +113,75 @@
     GpRegion *region, *region2;
     RegionDataPoint *point;
     UINT needed;
-    DWORD buf[100];
+    DWORD buf[256];
     GpRect rect;
     GpPath *path;
+    GpMatrix *matrix;
+
+    status = GdipCreateRegion(&region);
+    ok(status == Ok, "status %08x\n", status);
+
+    needed = 0;
+    status = GdipGetRegionDataSize(region, &needed);
+    ok(status == Ok, "status %08x\n", status);
+    expect(20, needed);
+
+    needed = 0;
+    status = GdipGetRegionData(region, (BYTE*)buf, 0, &needed);
+    ok(status == InvalidParameter, "status %08x\n", status);
 
     memset(buf, 0xee, sizeof(buf));
-
-    status = GdipCreateRegion(&region);
-    ok(status == Ok, "status %08x\n", status);
-
-    status = GdipGetRegionDataSize(region, &needed);
-    ok(status == Ok, "status %08x\n", status);
-    expect(20, needed);
+    needed = 0;
+    status = GdipGetRegionData(region, (BYTE*)buf, 4, &needed);
+    ok(status == InsufficientBuffer, "status %08x\n", status);
+    expect(4, needed);
+    expect_dword(buf, 0xeeeeeeee);
+
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(20, needed);
     expect_dword(buf, 12);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
+    expect_dword(buf + 6, 0xeeeeeeee);
 
     status = GdipSetEmpty(region);
     ok(status == Ok, "status %08x\n", status);
     status = GdipGetRegionDataSize(region, &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(20, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(20, needed);
     expect_dword(buf, 12);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_EMPTY_RECT);
+    expect_dword(buf + 6, 0xeeeeeeee);
 
     status = GdipSetInfinite(region);
     ok(status == Ok, "status %08x\n", status);
     status = GdipGetRegionDataSize(region, &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(20, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(20, needed);
     expect_dword(buf, 12);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
+    expect_dword(buf + 6, 0xeeeeeeee);
 
     status = GdipDeleteRegion(region);
     ok(status == Ok, "status %08x\n", status);
@@ -176,18 +195,21 @@
     status = GdipGetRegionDataSize(region, &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(36, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(36, needed);
     expect_dword(buf, 28);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_RECT);
     expect_float(buf + 5, 10.0);
     expect_float(buf + 6, 20.0);
     expect_float(buf + 7, 100.0);
     expect_float(buf + 8, 200.0);
+    expect_dword(buf + 10, 0xeeeeeeee);
 
     rect.X = 50;
     rect.Y = 30;
@@ -228,12 +250,14 @@
     status = GdipGetRegionDataSize(region, &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(156, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(156, needed);
     expect_dword(buf, 148);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 10);
     expect_dword(buf + 4, CombineModeExclude);
     expect_dword(buf + 5, CombineModeComplement);
@@ -270,6 +294,7 @@
     expect_float(buf + 36, 500.0);
     expect_float(buf + 37, 22.0);
     expect_float(buf + 38, 55.0);
+    expect_dword(buf + 39, 0xeeeeeeee);
 
     status = GdipDeleteRegion(region2);
     ok(status == Ok, "status %08x\n", status);
@@ -287,16 +312,18 @@
     status = GdipGetRegionDataSize(region, &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(72, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(72, needed);
     expect_dword(buf, 64);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_PATH);
     expect_dword(buf + 5, 0x00000030);
-    expect_magic((DWORD*)(buf + 6));
+    expect_magic(buf + 6);
     expect_dword(buf + 7, 0x00000004);
     expect_dword(buf + 8, 0x00000000);
     expect_float(buf + 9, 12.5);
@@ -308,7 +335,7 @@
     expect_float(buf + 15, 12.5);
     expect_float(buf + 16, 28.0);
     expect_dword(buf + 17, 0x81010100);
-
+    expect_dword(buf + 18, 0xeeeeeeee);
 
     rect.X = 50;
     rect.Y = 30;
@@ -319,17 +346,19 @@
     status = GdipGetRegionDataSize(region, &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(96, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     ok(status == Ok, "status %08x\n", status);
     expect(96, needed);
     expect_dword(buf, 88);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 2);
     expect_dword(buf + 4, CombineModeIntersect);
     expect_dword(buf + 5, RGNDATA_PATH);
     expect_dword(buf + 6, 0x00000030);
-    expect_magic((DWORD*)(buf + 7));
+    expect_magic(buf + 7);
     expect_dword(buf + 8, 0x00000004);
     expect_dword(buf + 9, 0x00000000);
     expect_float(buf + 10, 12.5);
@@ -346,6 +375,7 @@
     expect_float(buf + 21, 30.0);
     expect_float(buf + 22, 10.0);
     expect_float(buf + 23, 20.0);
+    expect_dword(buf + 24, 0xeeeeeeee);
 
     status = GdipDeleteRegion(region);
     ok(status == Ok, "status %08x\n", status);
@@ -360,22 +390,31 @@
     status = GdipGetRegionDataSize(region, &needed);
     expect(Ok, status);
     expect(36, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     expect(Ok, status);
     expect(36, needed);
     expect_dword(buf, 28);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_PATH);
-
     /* Second signature for pathdata */
     expect_dword(buf + 5, 12);
-    expect_magic((DWORD*)(buf + 6));
+    expect_magic(buf + 6);
     expect_dword(buf + 7, 0);
-    /* flags 0x4000 means its a path of shorts instead of FLOAT */
-    ok((*(buf + 8) & (~ 0x00004000)) == 0x00000000,
-       "expected 00000000 got %08x\n", *(buf + 8) & (~ 0x00004000));
+    /* flags 0 means that a path is an array of FLOATs */
+    ok(*(buf + 8) == 0x4000 /* before win7 */ || *(buf + 8) == 0,
+       "expected 0x4000 or 0, got %08x\n", *(buf + 8));
+    expect_dword(buf + 10, 0xeeeeeeee);
+
+    /* Transform an empty region */
+    status = GdipCreateMatrix(&matrix);
+    expect(Ok, status);
+    status = GdipTransformRegion(region, matrix);
+    expect(Ok, status);
+    GdipDeleteMatrix(matrix);
 
     status = GdipDeleteRegion(region);
     expect(Ok, status);
@@ -392,21 +431,23 @@
     status = GdipGetRegionDataSize(region, &needed);
     expect(Ok, status);
     expect(56, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     expect(Ok, status);
     expect(56, needed);
     expect_dword(buf, 48);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3 , 0);
     expect_dword(buf + 4 , RGNDATA_PATH);
-
     expect_dword(buf + 5, 32);
-    expect_magic((DWORD*)(buf + 6));
+    expect_magic(buf + 6);
     expect_dword(buf + 7, 4);
-    expect_dword(buf + 8, 0x00004000); /* ?? */
-
-    point = (RegionDataPoint*)buf + 9;
+    /* flags 0x4000 means that a path is an array of shorts instead of FLOATs */
+    expect_dword(buf + 8, 0x4000);
+
+    point = (RegionDataPoint*)(buf + 9);
     expect(5, point[0].X);
     expect(6, point[0].Y);
     expect(7, point[1].X); /* buf + 10 */
@@ -416,6 +457,34 @@
     expect(5, point[3].X); /* buf + 12 */
     expect(6, point[3].Y);
     expect_dword(buf + 13, 0x81010100); /* 0x01010100 if we don't close the path */
+    expect_dword(buf + 14, 0xeeeeeeee);
+
+    status = GdipTranslateRegion(region, 0.6, 0.8);
+    expect(Ok, status);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
+    status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
+    expect(Ok, status);
+    expect(72, needed);
+    expect_dword(buf, 64);
+    expect_magic(buf + 2);
+    expect_dword(buf + 3 , 0);
+    expect_dword(buf + 4 , RGNDATA_PATH);
+    expect_dword(buf + 5, 48);
+    expect_magic(buf + 6);
+    expect_dword(buf + 7, 4);
+    /* flags 0 means that a path is an array of FLOATs */
+    expect_dword(buf + 8, 0);
+    expect_float(buf + 9, 5.6);
+    expect_float(buf + 10, 6.8);
+    expect_float(buf + 11, 7.6);
+    expect_float(buf + 12, 8.8);
+    expect_float(buf + 13, 8.6);
+    expect_float(buf + 14, 1.8);
+    expect_float(buf + 15, 5.6);
+    expect_float(buf + 16, 6.8);
+    expect_dword(buf + 17, 0x81010100); /* 0x01010100 if we don't close the path */
+    expect_dword(buf + 18, 0xeeeeeeee);
 
     status = GdipDeletePath(path);
     expect(Ok, status);
@@ -434,17 +503,18 @@
     status = GdipGetRegionDataSize(region, &needed);
     expect(Ok, status);
     expect(72, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     expect(Ok, status);
     expect(72, needed);
     expect_dword(buf, 64);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_PATH);
-
     expect_dword(buf + 5, 48);
-    expect_magic((DWORD*)(buf + 6));
+    expect_magic(buf + 6);
     expect_dword(buf + 7, 4);
     expect_dword(buf + 8, 0);
     expect_float(buf + 9, 5.6);
@@ -455,6 +525,8 @@
     expect_float(buf + 14, 1.6);
     expect_float(buf + 15, 5.6);
     expect_float(buf + 16, 6.2);
+    expect_dword(buf + 17, 0x01010100);
+    expect_dword(buf + 18, 0xeeeeeeee);
 
     status = GdipDeletePath(path);
     expect(Ok, status);
@@ -481,29 +553,29 @@
     status = GdipGetRegionDataSize(region, &needed);
     expect(Ok, status);
     expect(116, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
     status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
     expect(Ok, status);
     expect(116, needed);
     expect_dword(buf, 108);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 2);
     expect_dword(buf + 4, CombineModeUnion);
     expect_dword(buf + 5, RGNDATA_RECT);
-    expect_float(buf + 6, 20);
-    expect_float(buf + 7, 25);
-    expect_float(buf + 8, 60);
-    expect_float(buf + 9, 120);
+    expect_float(buf + 6, 20.0);
+    expect_float(buf + 7, 25.0);
+    expect_float(buf + 8, 60.0);
+    expect_float(buf + 9, 120.0);
     expect_dword(buf + 10, RGNDATA_PATH);
-
     expect_dword(buf + 11, 68);
-    expect_magic((DWORD*)(buf + 12));
+    expect_magic(buf + 12);
     expect_dword(buf + 13, 6);
-    expect_float(buf + 14, 0x0);
-
-    expect_float(buf + 15, 50);
+    expect_float(buf + 14, 0.0);
+    expect_float(buf + 15, 50.0);
     expect_float(buf + 16, 70.2);
-    expect_float(buf + 17, 60);
+    expect_float(buf + 17, 60.0);
     expect_float(buf + 18, 102.8);
     expect_float(buf + 19, 55.4);
     expect_float(buf + 20, 122.4);
@@ -511,11 +583,160 @@
     expect_float(buf + 22, 60.2);
     expect_float(buf + 23, 45.6);
     expect_float(buf + 24, 20.2);
-    expect_float(buf + 25, 50);
+    expect_float(buf + 25, 50.0);
     expect_float(buf + 26, 70.2);
     expect_dword(buf + 27, 0x01010100);
     ok(*(buf + 28) == 0x00000101 || *(buf + 28) == 0x43050101 /* Win 7 */,
        "expected 00000101 or 43050101 got %08x\n", *(buf + 28));
+    expect_dword(buf + 29, 0xeeeeeeee);
+
+    status = GdipDeletePath(path);
+    expect(Ok, status);
+    status = GdipDeleteRegion(region);
+    expect(Ok, status);
+
+    /* Test how shorts are stored in the region path data */
+    status = GdipCreatePath(FillModeAlternate, &path);
+    ok(status == Ok, "status %08x\n", status);
+    GdipAddPathRectangleI(path, -1969, -1974, 1995, 1997);
+
+    status = GdipCreateRegionPath(path, &region);
+    ok(status == Ok, "status %08x\n", status);
+    needed = 0;
+    status = GdipGetRegionDataSize(region, &needed);
+    ok(status == Ok, "status %08x\n", status);
+    expect(56, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
+    status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
+    ok(status == Ok, "status %08x\n", status);
+    expect(56, needed);
+    expect_dword(buf, 48);
+    trace("buf[1] = %08x\n", buf[1]);
+    expect_magic(buf + 2);
+    expect_dword(buf + 3, 0);
+    expect_dword(buf + 4, RGNDATA_PATH);
+    expect_dword(buf + 5, 32);
+    expect_magic(buf + 6);
+    expect_dword(buf + 7, 4);
+    /* flags 0x4000 means that a path is an array of shorts instead of FLOATs */
+    expect_dword(buf + 8, 0x4000);
+    point = (RegionDataPoint*)(buf + 9);
+    expect(-1969, point[0].X);
+    expect(-1974, point[0].Y);
+    expect(26, point[1].X); /* buf + 10 */
+    expect(-1974, point[1].Y);
+    expect(26, point[2].X); /* buf + 11 */
+    expect(23, point[2].Y);
+    expect(-1969, point[3].X); /* buf + 12 */
+    expect(23, point[3].Y);
+    expect_dword(buf + 13, 0x81010100); /* 0x01010100 if we don't close the path */
+    expect_dword(buf + 14, 0xeeeeeeee);
+
+    status = GdipDeletePath(path);
+    expect(Ok, status);
+    status = GdipDeleteRegion(region);
+    expect(Ok, status);
+
+    /* Test with integers that can't be stored as shorts */
+    status = GdipCreatePath(FillModeAlternate, &path);
+    ok(status == Ok, "status %08x\n", status);
+    GdipAddPathRectangleI(path, -196900, -197400, 199500, 199700);
+
+    status = GdipCreateRegionPath(path, &region);
+    ok(status == Ok, "status %08x\n", status);
+    needed = 0;
+    status = GdipGetRegionDataSize(region, &needed);
+    ok(status == Ok, "status %08x\n", status);
+    expect(72, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
+    status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
+    ok(status == Ok, "status %08x\n", status);
+    expect(72, needed);
+    expect_dword(buf, 64);
+    trace("buf[1] = %08x\n", buf[1]);
+    expect_magic(buf + 2);
+    expect_dword(buf + 3, 0);
+    expect_dword(buf + 4, RGNDATA_PATH);
+    expect_dword(buf + 5, 48);
+    expect_magic(buf + 6);
+    expect_dword(buf + 7, 4);
+    /* flags 0 means that a path is an array of FLOATs */
+    expect_dword(buf + 8, 0);
+    expect_float(buf + 9, -196900.0);
+    expect_float(buf + 10, -197400.0);
+    expect_float(buf + 11, 2600.0);
+    expect_float(buf + 12, -197400.0);
+    expect_float(buf + 13, 2600.0);
+    expect_float(buf + 14, 2300.0);
+    expect_float(buf + 15, -196900.0);
+    expect_float(buf + 16, 2300.0);
+    expect_dword(buf + 17, 0x81010100); /* 0x01010100 if we don't close the path */
+    expect_dword(buf + 18, 0xeeeeeeee);
+
+    status = GdipDeletePath(path);
+    expect(Ok, status);
+    status = GdipDeleteRegion(region);
+    expect(Ok, status);
+
+    /* Test beziers */
+    GdipCreatePath(FillModeAlternate, &path);
+      /* Exactly 90 degrees */
+    status = GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 90.0);
+    expect(Ok, status);
+    /* Over 90 degrees */
+    status = GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
+    expect(Ok, status);
+    status = GdipCreateRegionPath(path, &region);
+    ok(status == Ok, "status %08x\n", status);
+    needed = 0;
+    status = GdipGetRegionDataSize(region, &needed);
+    ok(status == Ok, "status %08x\n", status);
+    expect(136, needed);
+    memset(buf, 0xee, sizeof(buf));
+    needed = 0;
+    status = GdipGetRegionData(region, (BYTE*)buf, sizeof(buf), &needed);
+    ok(status == Ok, "status %08x\n", status);
+    expect(136, needed);
+    expect_dword(buf, 128);
+    trace("buf[1] = %08x\n", buf[1]);
+    expect_magic(buf + 2);
+    expect_dword(buf + 3, 0);
+    expect_dword(buf + 4, RGNDATA_PATH);
+    expect_dword(buf + 5, 112);
+    expect_magic(buf + 6);
+    expect_dword(buf + 7, 11);
+    /* flags 0 means that a path is an array of FLOATs */
+    expect_dword(buf + 8, 0);
+    expect_float(buf + 9, 600.0);
+    expect_float(buf + 10, 450.0);
+    expect_float(buf + 11, 600.0);
+    expect_float(buf + 12, 643.299561);
+    expect_float(buf + 13, 488.071198);
+    expect_float(buf + 14, 800.0);
+    expect_float(buf + 15, 350.0);
+    expect_float(buf + 16, 800.0);
+    expect_float(buf + 17, 600.0);
+    expect_float(buf + 18, 450.0);
+    expect_float(buf + 19, 600.0);
+    expect_float(buf + 20, 643.299622);
+    expect_float(buf + 21, 488.071167);
+    expect_float(buf + 22, 800.0);
+    expect_float(buf + 23, 350.0);
+    expect_float(buf + 24, 800.0);
+    expect_float(buf + 25, 329.807129);
+    expect_float(buf + 26, 800.0);
+    expect_float(buf + 27, 309.688568);
+    expect_float(buf + 28, 796.574890);
+    expect_float(buf + 29, 290.084167);
+    expect_float(buf + 30, 789.799561);
+    expect_dword(buf + 31, 0x03030300);
+    expect_dword(buf + 32, 0x03030301);
+    ok(*(buf + 33) == 0x00030303 /* before win7 */ ||
+       *(buf + 33) == 0x43030303 /* 32-bit win7 */ || *(buf + 33) == 0x4c030303 /* 64-bit
win7 */,
+       "expected 0x00030303 or 0x43030303 or 0x4c030303 got %08x\n", *(buf +
33));
+    expect_dword(buf + 34, 0xeeeeeeee);
 
     status = GdipDeletePath(path);
     expect(Ok, status);
@@ -640,7 +861,7 @@
     expect(36, needed);
     expect_dword(buf, 28);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_RECT);
 
@@ -660,7 +881,7 @@
     expect(156, needed);
     expect_dword(buf, 148);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_PATH);
     GdipDeletePath(path);
@@ -679,7 +900,7 @@
     expect(20, needed);
     expect_dword(buf, 12);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_INFINITE_RECT);
     GdipDeleteRegion(region2);
@@ -706,7 +927,7 @@
     expect(180, needed);
     expect_dword(buf, 172);
     trace("buf[1] = %08x\n", buf[1]);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 2);
     expect_dword(buf + 4, CombineModeUnion);
 
@@ -770,11 +991,11 @@
 
     expect(56, needed);
     expect_dword(buf, 48);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_PATH);
     expect_dword(buf + 5, 0x00000020);
-    expect_magic((DWORD*)(buf + 6));
+    expect_magic(buf + 6);
     expect_dword(buf + 7, 0x00000004);
     todo_wine expect_dword(buf + 8, 0x00006000); /* ?? */
 
@@ -817,11 +1038,11 @@
     expect(Ok, status);
     expect(216, needed);
     expect_dword(buf, 208);
-    expect_magic((DWORD*)(buf + 2));
+    expect_magic(buf + 2);
     expect_dword(buf + 3, 0);
     expect_dword(buf + 4, RGNDATA_PATH);
     expect_dword(buf + 5, 0x000000C0);
-    expect_magic((DWORD*)(buf + 6));
+    expect_magic(buf + 6);
     expect_dword(buf + 7, 0x00000024);
     todo_wine expect_dword(buf + 8, 0x00006000); /* ?? */
     }
@@ -861,12 +1082,10 @@
     status = GdipGetRegionHRgn(region, NULL, &hrgn);
     ok(status == Ok, "status %08x\n", status);
     ok(hrgn == NULL, "hrgn=%p\n", hrgn);
-    DeleteObject(hrgn);
 
     status = GdipGetRegionHRgn(region, graphics, &hrgn);
     ok(status == Ok, "status %08x\n", status);
     ok(hrgn == NULL, "hrgn=%p\n", hrgn);
-    DeleteObject(hrgn);
 
     status = GdipSetEmpty(region);
     ok(status == Ok, "status %08x\n", status);
@@ -1866,6 +2085,56 @@
     GdipDeleteRegion(region);
     GdipDeleteGraphics(graphics);
     ReleaseDC(0, hdc);
+}
+
+static void test_excludeinfinite(void)
+{
+    GpStatus status;
+    GpRegion *region;
+    UINT count=0xdeadbeef;
+    GpRectF scans[4];
+    GpMatrix *identity;
+    static const RectF rect_exclude = {0.0, 0.0, 1.0, 1.0};
+
+    status = GdipCreateMatrix(&identity);
+    expect(Ok, status);
+
+    status = GdipCreateRegion(&region);
+    expect(Ok, status);
+
+    status = GdipCombineRegionRect(region, &rect_exclude, CombineModeExclude);
+    expect(Ok, status);
+
+    status = GdipGetRegionScansCount(region, &count, identity);
+    expect(Ok, status);
+    expect(4, count);
+
+    count = 4;
+    status = GdipGetRegionScans(region, scans, (INT*)&count, identity);
+    expect(Ok, status);
+
+    expectf(-4194304.0, scans[0].X);
+    expectf(-4194304.0, scans[0].Y);
+    expectf(8388608.0, scans[0].Width);
+    expectf(4194304.0, scans[0].Height);
+
+    expectf(-4194304.0, scans[1].X);
+    expectf(0.0, scans[1].Y);
+    expectf(4194304.0, scans[1].Width);
+    expectf(1.0, scans[1].Height);
+
+    expectf(1.0, scans[2].X);
+    expectf(0.0, scans[2].Y);
+    expectf(4194303.0, scans[2].Width);
+    expectf(1.0, scans[2].Height);
+
+    expectf(-4194304.0, scans[3].X);
+    expectf(1.0, scans[3].Y);
+    expectf(8388608.0, scans[3].Width);
+    expectf(4194303.0, scans[3].Height);
+
+    GdipDeleteRegion(region);
+    GdipDeleteMatrix(identity);
 }
 
 START_TEST(region)
@@ -1893,6 +2162,7 @@
     test_getbounds();
     test_isvisiblepoint();
     test_isvisiblerect();
+    test_excludeinfinite();
 
     GdiplusShutdown(gdiplusToken);
 }