[ros-diffs] [akhaldi] 71779: [GDI32_WINETEST] Sync with Wine Staging 1.9.11. CORE-11368 CORE-11331

Author: akhaldi
Date: Sun Jul  3 11:29:52 2016
New Revision: 71779

URL: http://svn.reactos.org/svn/reactos?rev=71779&view=rev
Log:
[GDI32_WINETEST] Sync with Wine Staging 1.9.11. CORE-11368 CORE-11331

Modified:
    trunk/rostests/winetests/gdi32/bitmap.c
    trunk/rostests/winetests/gdi32/dc.c
    trunk/rostests/winetests/gdi32/font.c
    trunk/rostests/winetests/gdi32/metafile.c

Modified: trunk/rostests/winetests/gdi32/bitmap.c
URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdi32/bitmap.c?r...
==============================================================================
--- trunk/rostests/winetests/gdi32/bitmap.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdi32/bitmap.c	[iso-8859-1] Sun Jul  3 11:29:52 2016
@@ -23,15 +23,25 @@
 #include <assert.h>
 #include <string.h>

+#include "ntstatus.h"
+#define WIN32_NO_STATUS
 #include "windef.h"
 #include "winbase.h"
 #include "winerror.h"
 #include "wingdi.h"
 #include "winuser.h"
 #include "mmsystem.h"
+#include "wine/winternl.h"
+#ifndef __REACTOS__ /* CORE-11331 */
+#include "wine/ddk/d3dkmthk.h"
+#endif

#include "wine/test.h"

+#ifndef __REACTOS__ /* CORE-11331 */
+static NTSTATUS (WINAPI *pD3DKMTCreateDCFromMemory)( D3DKMT_CREATEDCFROMMEMORY *desc );
+static NTSTATUS (WINAPI *pD3DKMTDestroyDCFromMemory)( const D3DKMT_DESTROYDCFROMMEMORY *desc );
+#endif
 static BOOL (WINAPI *pGdiAlphaBlend)(HDC,int,int,int,int,HDC,int,int,int,int,BLENDFUNCTION);
 static BOOL (WINAPI *pGdiGradientFill)(HDC,TRIVERTEX*,ULONG,void*,ULONG,ULONG);
 static DWORD (WINAPI *pSetLayout)(HDC hdc, DWORD layout);
@@ -5651,14 +5661,265 @@
     HeapFree( GetProcessHeap(), 0, info );
 }

+#ifndef __REACTOS__ /* CORE-11331 */
+static void test_D3DKMTCreateDCFromMemory( void )
+{
+    D3DKMT_DESTROYDCFROMMEMORY destroy_desc;
+    D3DKMT_CREATEDCFROMMEMORY create_desc;
+    unsigned int width_bytes;
+    unsigned int i, x, y, z;
+    DWORD expected, colour;
+    BYTE data[12][48];
+    NTSTATUS status;
+    HGDIOBJ *bitmap;
+    DIBSECTION dib;
+    BOOL fail, ret;
+    DWORD type;
+    int size;
+
+    static const struct
+    {
+        const char *name;
+        D3DDDIFORMAT format;
+        unsigned int bit_count;
+        DWORD mask_r, mask_g, mask_b;
+        NTSTATUS status;
+    }
+    test_data[] =
+    {
+        { "R8G8B8",      D3DDDIFMT_R8G8B8,      24, 0x00000000, 0x00000000, 0x00000000, STATUS_SUCCESS },
+        { "A8R8G8B8",    D3DDDIFMT_A8R8G8B8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_SUCCESS },
+        { "X8R8G8B8",    D3DDDIFMT_X8R8G8B8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_SUCCESS },
+        { "R5G6B5",      D3DDDIFMT_R5G6B5,      16, 0x0000f800, 0x000007e0, 0x0000001f, STATUS_SUCCESS },
+        { "X1R5G5B5",    D3DDDIFMT_X1R5G5B5,    16, 0x00007c00, 0x000003e0, 0x0000001f, STATUS_SUCCESS },
+        { "A1R5G5B5",    D3DDDIFMT_A1R5G5B5,    16, 0x00007c00, 0x000003e0, 0x0000001f, STATUS_SUCCESS },
+        { "R3G3B2",      D3DDDIFMT_R3G3B2,      8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "A2B10G10R10", D3DDDIFMT_A2B10G10R10, 32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "A8B8G8R8",    D3DDDIFMT_A8B8G8R8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "X8B8G8R8",    D3DDDIFMT_A8B8G8R8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "A2R10G10B10", D3DDDIFMT_A2R10G10B10, 32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "P8",          D3DDDIFMT_P8,          8,  0x00000000, 0x00000000, 0x00000000, STATUS_SUCCESS },
+        { "L8",          D3DDDIFMT_L8,          8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "A8L8",        D3DDDIFMT_A8L8,        16, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "V8U8",        D3DDDIFMT_V8U8,        16, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "Q8W8V8U8",    D3DDDIFMT_Q8W8V8U8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "DXT1",        D3DDDIFMT_DXT1,        4,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "DXT2",        D3DDDIFMT_DXT2,        8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "DXT3",        D3DDDIFMT_DXT3,        8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "DXT4",        D3DDDIFMT_DXT4,        8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+        { "DXT5",        D3DDDIFMT_DXT5,        8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
+    };
+
+    if (!pD3DKMTCreateDCFromMemory)
+    {
+        win_skip("D3DKMTCreateDCFromMemory() is not implemented.\n");
+        return;
+    }
+
+    status = pD3DKMTCreateDCFromMemory( NULL );
+    ok(status == STATUS_INVALID_PARAMETER, "Got unexpected status %#x.\n", status);
+
+    for (i = 0; i < sizeof(test_data) / sizeof(*test_data); ++i)
+    {
+        memset( data, 0xaa, sizeof(data) );
+
+        create_desc.pMemory = data;
+        create_desc.Format = test_data[i].format;
+        create_desc.Width = 9;
+        create_desc.Height = 7;
+        create_desc.Pitch = sizeof(*data);
+        create_desc.hDeviceDc = NULL;
+        create_desc.pColorTable = NULL;
+        create_desc.hDc = (void *)0x010baade;
+        create_desc.hBitmap = (void *)0x020baade;
+
+        status = pD3DKMTCreateDCFromMemory( &create_desc );
+        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n",
+           test_data[i].name, status);
+
+        create_desc.hDeviceDc = CreateCompatibleDC( NULL );
+        create_desc.pMemory = NULL;
+        status = pD3DKMTCreateDCFromMemory( &create_desc );
+        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n",
+           test_data[i].name, status);
+
+        create_desc.pMemory = data;
+        create_desc.Height = 0;
+        status = pD3DKMTCreateDCFromMemory( &create_desc );
+        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n",
+           test_data[i].name, status);
+        ok(create_desc.hDc == (void *)0x010baade, "%s: Got unexpected dc %p.\n",
+           test_data[i].name, create_desc.hDc);
+        ok(create_desc.hBitmap == (void *)0x020baade, "%s: Got unexpected bitmap %p.\n",
+           test_data[i].name, create_desc.hBitmap);
+
+        create_desc.Height = 7;
+        create_desc.Width = 0;
+        status = pD3DKMTCreateDCFromMemory( &create_desc );
+        ok(status == test_data[i].status, "%s: Got unexpected status %#x, expected %#x.\n",
+           test_data[i].name, status, test_data[i].status);
+        if (status == STATUS_SUCCESS)
+        {
+            destroy_desc.hDc = create_desc.hDc;
+            destroy_desc.hBitmap = create_desc.hBitmap;
+            status = pD3DKMTDestroyDCFromMemory( &destroy_desc );
+            ok(status == STATUS_SUCCESS, "%s: Got unexpected status %#x.\n", test_data[i].name, status);
+            create_desc.hDc = (void *)0x010baade;
+            create_desc.hBitmap = (void *)0x020baade;
+        }
+
+        create_desc.Pitch = 0;
+        status = pD3DKMTCreateDCFromMemory( &create_desc );
+        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n",
+           test_data[i].name, status);
+        ok(create_desc.hDc == (void *)0x010baade, "%s: Got unexpected dc %p.\n",
+           test_data[i].name, create_desc.hDc);
+        ok(create_desc.hBitmap == (void *)0x020baade, "%s: Got unexpected bitmap %p.\n",
+           test_data[i].name, create_desc.hBitmap);
+
+        create_desc.Width = 9;
+        create_desc.Pitch = sizeof(*data);
+        status = pD3DKMTCreateDCFromMemory( &create_desc );
+        ok(status == test_data[i].status, "%s: Got unexpected status %#x, expected %#x.\n",
+           test_data[i].name, status, test_data[i].status);
+        if (status == STATUS_SUCCESS)
+        {
+            ok(!!create_desc.hDc, "%s: Got unexpected dc %p.\n",
+               test_data[i].name, create_desc.hDc);
+            ok(!!create_desc.hBitmap, "%s: Got unexpected bitmap %p.\n",
+               test_data[i].name, create_desc.hBitmap);
+        }
+        else
+        {
+            ok(create_desc.hDc == (void *)0x010baade, "%s: Got unexpected dc %p.\n",
+               test_data[i].name, create_desc.hDc);
+            ok(create_desc.hBitmap == (void *)0x020baade, "%s: Got unexpected bitmap %p.\n",
+               test_data[i].name, create_desc.hBitmap);
+            continue;
+        }
+
+        type = GetObjectType( create_desc.hDc );
+        ok(type == OBJ_MEMDC, "%s: Got unexpected object type %#x.\n", test_data[i].name, type);
+        type = GetObjectType( create_desc.hBitmap );
+        ok(type == OBJ_BITMAP, "%s: Got unexpected object type %#x.\n", test_data[i].name, type);
+        bitmap = GetCurrentObject( create_desc.hDc, OBJ_BITMAP );
+        ok(bitmap == create_desc.hBitmap, "%s: Got unexpected bitmap %p, expected %p.\n",
+           test_data[i].name, bitmap, create_desc.hBitmap);
+
+        size = GetObjectA( bitmap, sizeof(dib), &dib );
+        ok(size == sizeof(dib), "%s: Got unexpected size %d.\n", test_data[i].name, size);
+        ok(!dib.dsBm.bmType, "%s: Got unexpected type %#x.\n",
+           test_data[i].name, dib.dsBm.bmType);
+        ok(dib.dsBm.bmWidth == create_desc.Width, "%s: Got unexpected width %d.\n",
+           test_data[i].name, dib.dsBm.bmWidth);
+        ok(dib.dsBm.bmHeight == create_desc.Height, "%s: Got unexpected height %d.\n",
+           test_data[i].name, dib.dsBm.bmHeight);
+        width_bytes = get_dib_stride( create_desc.Width, test_data[i].bit_count );
+        ok(dib.dsBm.bmWidthBytes == width_bytes, "%s: Got unexpected width bytes %d.\n",
+           test_data[i].name, dib.dsBm.bmWidthBytes);
+        ok(dib.dsBm.bmPlanes == 1, "%s: Got unexpected plane count %d.\n",
+           test_data[i].name, dib.dsBm.bmPlanes);
+        ok(dib.dsBm.bmBitsPixel == test_data[i].bit_count, "%s: Got unexpected bit count %d.\n",
+           test_data[i].name, dib.dsBm.bmBitsPixel);
+        ok(dib.dsBm.bmBits == create_desc.pMemory, "%s: Got unexpected bits %p, expected %p.\n",
+           test_data[i].name, dib.dsBm.bmBits, create_desc.pMemory);
+
+        ok(dib.dsBmih.biSize == sizeof(dib.dsBmih), "%s: Got unexpected size %u.\n",
+           test_data[i].name, dib.dsBmih.biSize);
+        ok(dib.dsBmih.biWidth == create_desc.Width, "%s: Got unexpected width %d.\n",
+           test_data[i].name, dib.dsBmih.biHeight);
+        ok(dib.dsBmih.biHeight == create_desc.Height, "%s: Got unexpected height %d.\n",
+           test_data[i].name, dib.dsBmih.biHeight);
+        ok(dib.dsBmih.biPlanes == 1, "%s: Got unexpected plane count %u.\n",
+           test_data[i].name, dib.dsBmih.biPlanes);
+        ok(dib.dsBmih.biBitCount == test_data[i].bit_count, "%s: Got unexpected bit count %u.\n",
+           test_data[i].name, dib.dsBmih.biBitCount);
+        ok(dib.dsBmih.biCompression == (test_data[i].bit_count == 16 ? BI_BITFIELDS : BI_RGB),
+           "%s: Got unexpected compression %#x.\n",
+           test_data[i].name, dib.dsBmih.biCompression);
+        ok(!dib.dsBmih.biSizeImage, "%s: Got unexpected image size %u.\n",
+           test_data[i].name, dib.dsBmih.biSizeImage);
+        ok(!dib.dsBmih.biXPelsPerMeter, "%s: Got unexpected horizontal resolution %d.\n",
+           test_data[i].name, dib.dsBmih.biXPelsPerMeter);
+        ok(!dib.dsBmih.biYPelsPerMeter, "%s: Got unexpected vertical resolution %d.\n",
+           test_data[i].name, dib.dsBmih.biYPelsPerMeter);
+        if (test_data[i].format == D3DDDIFMT_P8)
+        {
+            ok(dib.dsBmih.biClrUsed == 256, "%s: Got unexpected used colour count %u.\n",
+               test_data[i].name, dib.dsBmih.biClrUsed);
+            ok(dib.dsBmih.biClrImportant == 256, "%s: Got unexpected important colour count %u.\n",
+               test_data[i].name, dib.dsBmih.biClrImportant);
+        }
+        else
+        {
+            ok(!dib.dsBmih.biClrUsed, "%s: Got unexpected used colour count %u.\n",
+               test_data[i].name, dib.dsBmih.biClrUsed);
+            ok(!dib.dsBmih.biClrImportant, "%s: Got unexpected important colour count %u.\n",
+               test_data[i].name, dib.dsBmih.biClrImportant);
+        }
+
+        ok(dib.dsBitfields[0] == test_data[i].mask_r && dib.dsBitfields[1] == test_data[i].mask_g
+           && dib.dsBitfields[2] == test_data[i].mask_b,
+           "%s: Got unexpected colour masks 0x%08x 0x%08x 0x%08x.\n",
+           test_data[i].name, dib.dsBitfields[0], dib.dsBitfields[1], dib.dsBitfields[2]);
+        ok(!dib.dshSection, "%s: Got unexpected section %p.\n", test_data[i].name, dib.dshSection);
+        ok(!dib.dsOffset, "%s: Got unexpected offset %u.\n", test_data[i].name, dib.dsOffset);
+
+        ret = BitBlt( create_desc.hDc, 0, 0, 4, 10, NULL, 0, 0, BLACKNESS );
+        ok(ret, "Failed to blit.\n");
+        ret = BitBlt( create_desc.hDc, 1, 1, 2, 2, NULL, 0, 0, WHITENESS );
+        ok(ret, "Failed to blit.\n");
+
+        destroy_desc.hDc = create_desc.hDc;
+        destroy_desc.hBitmap = create_desc.hBitmap;
+
+        status = pD3DKMTDestroyDCFromMemory( NULL );
+        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n", test_data[i].name, status);
+        status = pD3DKMTDestroyDCFromMemory( &destroy_desc );
+        ok(status == STATUS_SUCCESS, "%s: Got unexpected status %#x.\n", test_data[i].name, status);
+        status = pD3DKMTDestroyDCFromMemory( &destroy_desc );
+        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n", test_data[i].name, status);
+
+        ret = DeleteDC( create_desc.hDeviceDc );
+        ok(ret, "Failed to delete dc.\n");
+
+        for (y = 0, fail = FALSE; y < 12 && !fail; ++y)
+        {
+            for (x = 0; x < sizeof(*data) / (test_data[i].bit_count / 8) && !fail; ++x)
+            {
+                for (z = 0, colour = 0; z < test_data[i].bit_count / 8; ++z)
+                {
+                    colour = colour << 8 | data[y][x * (test_data[i].bit_count / 8) + z];
+                }
+
+                if ((x == 1 || x == 2) && (y == 1 || y == 2))
+                    expected = 0xffffffff >> (32 - test_data[i].bit_count);
+                else if (x < 4 && y < 7)
+                    expected = 0x00000000;
+                else
+                    expected = 0xaaaaaaaa >> (32 - test_data[i].bit_count);
+                ok(colour == expected, "%s: Got unexpected colour 0x%08x at %u, %u, expected 0x%08x.\n",
+                   test_data[i].name, colour, x, y, expected);
+                if (colour != expected)
+                    fail = TRUE;
+            }
+        }
+    }
+}
+#endif /* __REACTOS__ */
+
 START_TEST(bitmap)
 {
     HMODULE hdll;

hdll = GetModuleHandleA("gdi32.dll");
-    pGdiAlphaBlend   = (void*)GetProcAddress(hdll, "GdiAlphaBlend");
-    pGdiGradientFill = (void*)GetProcAddress(hdll, "GdiGradientFill");
-    pSetLayout       = (void*)GetProcAddress(hdll, "SetLayout");
+#ifndef __REACTOS__ /* CORE-11331 */
+    pD3DKMTCreateDCFromMemory  = (void *)GetProcAddress( hdll, "D3DKMTCreateDCFromMemory" );
+    pD3DKMTDestroyDCFromMemory = (void *)GetProcAddress( hdll, "D3DKMTDestroyDCFromMemory" );
+#endif
+    pGdiAlphaBlend             = (void *)GetProcAddress( hdll, "GdiAlphaBlend" );
+    pGdiGradientFill           = (void *)GetProcAddress( hdll, "GdiGradientFill" );
+    pSetLayout                 = (void *)GetProcAddress( hdll, "SetLayout" );

test_createdibitmap();
     test_dibsections();
@@ -5695,4 +5956,7 @@
     test_SetDIBits_RLE8();
     test_SetDIBitsToDevice();
     test_SetDIBitsToDevice_RLE8();
+#ifndef __REACTOS__ /* CORE-11331 */
+    test_D3DKMTCreateDCFromMemory();
+#endif
 }

Modified: trunk/rostests/winetests/gdi32/dc.c
URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdi32/dc.c?rev=7...
==============================================================================
--- trunk/rostests/winetests/gdi32/dc.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdi32/dc.c	[iso-8859-1] Sun Jul  3 11:29:52 2016
@@ -2,7 +2,7 @@
  * Unit tests for dc functions
  *
  * Copyright (c) 2005 Huw Davies
- * Copyright (c) 2005 Dmitry Timoshkov
+ * Copyright (c) 2005,2016 Dmitry Timoshkov
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -812,7 +812,6 @@
     ok(ret, "UnregisterClassA failed\n");

ret = GetObjectType(hdc_test);
-todo_wine
     ok(!ret, "GetObjectType should fail for a deleted DC\n");

/* CS_OWNDC */
@@ -891,7 +890,7 @@
     ret = GetBoundsRect(hdc, &rect, 0);
     ok(ret == DCB_RESET,
        "Expected GetBoundsRect to return DCB_RESET, got %u\n", ret);
-    SetRect(&expect, 0, 0, 0, 0);
+    SetRectEmpty(&expect);
     ok(EqualRect(&rect, &expect) ||
        broken(EqualRect(&rect, &set_rect)), /* nt4 sp1-5 */
        "Expected output rectangle (0,0)-(0,0), got (%d,%d)-(%d,%d)\n",
@@ -986,7 +985,7 @@
        "GetBoundsRect returned %x\n", ret);
     if (ret == DCB_RESET)
     {
-        SetRect(&expect, 0, 0, 0, 0);
+        SetRectEmpty(&expect);
         ok(EqualRect(&rect, &expect), "Got (%d,%d)-(%d,%d)\n",
            rect.left, rect.top, rect.right, rect.bottom);

@@ -995,7 +994,7 @@
         ok(ret == (DCB_RESET | DCB_DISABLE), "SetBoundsRect returned %x\n", ret);
         ret = GetBoundsRect(hdc, &rect, 0);
         ok(ret == DCB_RESET, "GetBoundsRect returned %x\n", ret);
-        SetRect(&expect, 0, 0, 0, 0);
+        SetRectEmpty(&expect);
         ok(EqualRect(&rect, &expect), "Got (%d,%d)-(%d,%d)\n",
            rect.left, rect.top, rect.right, rect.bottom);
     }
@@ -1386,6 +1385,119 @@
     DeleteObject( bmp );
 }

+static void print_something(HDC hdc)
+{
+    static const char psadobe[10] = "%!PS-Adobe";
+    char buf[1024], *p;
+    char temp_path[MAX_PATH], file_name[MAX_PATH];
+    DOCINFOA di;
+    DWORD ret;
+    HANDLE hfile;
+
+    GetTempPathA(sizeof(temp_path), temp_path);
+    GetTempFileNameA(temp_path, "ps", 0, file_name);
+
+    di.cbSize = sizeof(di);
+    di.lpszDocName = "Let's dance";
+    di.lpszOutput = file_name;
+    di.lpszDatatype = NULL;
+    di.fwType = 0;
+    ret = StartDocA(hdc, &di);
+    ok(ret > 0, "StartDoc failed: %d\n", ret);
+
+    strcpy(buf + 2, "\n% ===> before DOWNLOADHEADER <===\n");
+    *(WORD *)buf = strlen(buf + 2);
+    ret = Escape(hdc, POSTSCRIPT_PASSTHROUGH, 0, buf, NULL);
+    ok(ret == *(WORD *)buf, "POSTSCRIPT_PASSTHROUGH failed: %d\n", ret);
+
+    strcpy(buf, "deadbeef");
+    ret = ExtEscape(hdc, DOWNLOADHEADER, 0, NULL, sizeof(buf), buf );
+    ok(ret == 1, "DOWNLOADHEADER failed\n");
+    ok(strcmp(buf, "deadbeef") != 0, "DOWNLOADHEADER failed\n");
+
+    strcpy(buf + 2, "\n% ===> after DOWNLOADHEADER <===\n");
+    *(WORD *)buf = strlen(buf + 2);
+    ret = Escape(hdc, POSTSCRIPT_PASSTHROUGH, 0, buf, NULL);
+    ok(ret == *(WORD *)buf, "POSTSCRIPT_PASSTHROUGH failed: %d\n", ret);
+
+    ret = EndDoc(hdc);
+    ok(ret == 1, "EndDoc failed\n");
+
+    hfile = CreateFileA(file_name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
+    ok(hfile != INVALID_HANDLE_VALUE, "CreateFile failed\n");
+    memset(buf, 0, sizeof(buf));
+    ret = ReadFile(hfile, buf, sizeof(buf), &ret, NULL);
+    ok(ret, "ReadFile failed\n");
+    CloseHandle(hfile);
+
+    /* skip the HP PCL language selector */
+    buf[sizeof(buf) - 1] = 0;
+    p = buf;
+    while (*p)
+    {
+        if (!(p[0] == 0x1b && p[1] == '%') && memcmp(p, "@PJL", 4) != 0)
+            break;
+
+        p = strchr(p, '\n');
+        if (!p) break;
+
+        while (*p == '\r' || *p == '\n') p++;
+    }
+    ok(p && !memcmp(p, psadobe, sizeof(psadobe)), "wrong signature: %.14s\n", p ? p : buf);
+
+    DeleteFileA(file_name);
+}
+
+static void test_pscript_printer_dc(void)
+{
+    HDC hdc;
+    char buf[256];
+    DWORD query, ret;
+
+    hdc = create_printer_dc(100, FALSE);
+
+    if (!hdc) return;
+
+    if (!is_postscript_printer(hdc))
+    {
+        skip("Default printer is not a PostScript device\n");
+        DeleteDC( hdc );
+        return;
+    }
+
+    query = GETFACENAME;
+    ret = Escape(hdc, QUERYESCSUPPORT, sizeof(query), (LPCSTR)&query, NULL);
+    ok(!ret, "GETFACENAME is supported\n");
+
+    query = DOWNLOADFACE;
+    ret = Escape(hdc, QUERYESCSUPPORT, sizeof(query), (LPCSTR)&query, NULL);
+    ok(ret == 1, "DOWNLOADFACE is not supported\n");
+
+    query = OPENCHANNEL;
+    ret = Escape(hdc, QUERYESCSUPPORT, sizeof(query), (LPCSTR)&query, NULL);
+    ok(ret == 1, "OPENCHANNEL is not supported\n");
+
+    query = DOWNLOADHEADER;
+    ret = Escape(hdc, QUERYESCSUPPORT, sizeof(query), (LPCSTR)&query, NULL);
+    ok(ret == 1, "DOWNLOADHEADER is not supported\n");
+
+    query = CLOSECHANNEL;
+    ret = Escape(hdc, QUERYESCSUPPORT, sizeof(query), (LPCSTR)&query, NULL);
+    ok(ret == 1, "CLOSECHANNEL is not supported\n");
+
+    query = POSTSCRIPT_PASSTHROUGH;
+    ret = Escape(hdc, QUERYESCSUPPORT, sizeof(query), (LPCSTR)&query, NULL);
+    ok(ret == 1, "POSTSCRIPT_PASSTHROUGH is not supported\n");
+
+    ret = ExtEscape(hdc, GETFACENAME, 0, NULL, sizeof(buf), buf);
+    ok(ret == 1, "GETFACENAME failed\n");
+    trace("face name: %s\n", buf);
+
+    print_something(hdc);
+
+    DeleteDC(hdc);
+}
+
 START_TEST(dc)
 {
     pSetLayout = (void *)GetProcAddress( GetModuleHandleA("gdi32.dll"), "SetLayout");
@@ -1400,4 +1512,5 @@
     test_desktop_colorres();
     test_gamma();
     test_printer_dc();
-}
+    test_pscript_printer_dc();
+}

Modified: trunk/rostests/winetests/gdi32/font.c
URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdi32/font.c?rev...
==============================================================================
--- trunk/rostests/winetests/gdi32/font.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdi32/font.c	[iso-8859-1] Sun Jul  3 11:29:52 2016
@@ -105,6 +105,22 @@
     pGetFontFileData = (void *)GetProcAddress(hgdi32, "GetFontFileData");

system_lang_id = PRIMARYLANGID(GetSystemDefaultLangID());
+}
+
+static void *heap_alloc( size_t len )
+{
+    return HeapAlloc( GetProcessHeap(), 0, len );
+}
+
+static void *heap_realloc( void *p, size_t len )
+{
+    if (!p) return heap_alloc( len );
+    return HeapReAlloc( GetProcessHeap(), 0, p, len );
+}
+
+static void heap_free( void *p )
+{
+    HeapFree( GetProcessHeap(), 0, p );
 }

static INT CALLBACK is_truetype_font_installed_proc(const LOGFONTA *elf, const TEXTMETRICA *ntm, DWORD type, LPARAM lParam)
@@ -1016,7 +1032,7 @@
                 ok(ret == expected_cs, "got charset %d, expected %d\n", ret, expected_cs);

trace("created %s, height %d charset %x dpi %d\n", face_name, tm.tmHeight, tm.tmCharSet, tm.tmDigitizedAspectX);
-            trace("expected %s, height %d scaled_hight %d, dpi %d\n", fd[i].face_name, height, fd[i].scaled_height, fd[i].dpi);
+            trace("expected %s, height %d scaled_height %d, dpi %d\n", fd[i].face_name, height, fd[i].scaled_height, fd[i].dpi);

if(fd[i].dpi == tm.tmDigitizedAspectX)
             {
@@ -2736,24 +2752,22 @@
     ReleaseDC(NULL, hdc);
 }

-#define MAX_ENUM_FONTS 4096
-
 struct enum_font_data
 {
-    int total;
-    LOGFONTA lf[MAX_ENUM_FONTS];
+    int total, size;
+    LOGFONTA *lf;
 };

struct enum_fullname_data
 {
-    int total;
-    ENUMLOGFONTA elf[MAX_ENUM_FONTS];
+    int total, size;
+    ENUMLOGFONTA *elf;
 };

struct enum_font_dataW
 {
-    int total;
-    LOGFONTW lf[MAX_ENUM_FONTS];
+    int total, size;
+    LOGFONTW *lf;
 };

static INT CALLBACK arial_enum_proc(const LOGFONTA *lf, const TEXTMETRICA *tm, DWORD type, LPARAM lParam)
@@ -2771,10 +2785,13 @@
     if (0) /* Disabled to limit console spam */
         trace("enumed font "%s", charset %d, height %d, weight %d, italic %d\n",
               lf->lfFaceName, lf->lfCharSet, lf->lfHeight, lf->lfWeight, lf->lfItalic);
-    if (efd->total < MAX_ENUM_FONTS)
-        efd->lf[efd->total++] = *lf;
-    else
-        trace("enum tests invalid; you have more than %d fonts\n", MAX_ENUM_FONTS);
+    if (efd->total >= efd->size)
+    {
+        efd->size = max( (efd->total + 1) * 2, 256 );
+        efd->lf = heap_realloc( efd->lf, efd->size * sizeof(*efd->lf) );
+        if (!efd->lf) return 0;
+    }
+    efd->lf[efd->total++] = *lf;

return 1;
 }
@@ -2794,10 +2811,13 @@
     if (0) /* Disabled to limit console spam */
         trace("enumed font %s, charset %d, height %d, weight %d, italic %d\n",
               wine_dbgstr_w(lf->lfFaceName), lf->lfCharSet, lf->lfHeight, lf->lfWeight, lf->lfItalic);
-    if (efd->total < MAX_ENUM_FONTS)
-        efd->lf[efd->total++] = *lf;
-    else
-        trace("enum tests invalid; you have more than %d fonts\n", MAX_ENUM_FONTS);
+    if (efd->total >= efd->size)
+    {
+        efd->size = max( (efd->total + 1) * 2, 256 );
+        efd->lf = heap_realloc( efd->lf, efd->size * sizeof(*efd->lf) );
+        if (!efd->lf) return 0;
+    }
+    efd->lf[efd->total++] = *lf;

return 1;
 }
@@ -2871,6 +2891,8 @@
         skip("%s is not installed\n", font_name);
         return;
     }
+    memset( &efd, 0, sizeof(efd) );
+    memset( &efdw, 0, sizeof(efdw) );

hdc = GetDC(0);

@@ -3064,6 +3086,9 @@
     }

ReleaseDC(0, hdc);
+
+    heap_free( efd.lf );
+    heap_free( efdw.lf );
 }

static INT CALLBACK enum_multi_charset_font_proc(const LOGFONTA *lf, const TEXTMETRICA *tm, DWORD type, LPARAM lParam)
@@ -3093,10 +3118,13 @@

if (type != TRUETYPE_FONTTYPE) return 1;

-    if (efd->total < MAX_ENUM_FONTS)
-        efd->lf[efd->total++] = *lf;
-    else
-        trace("enum tests invalid; you have more than %d fonts\n", MAX_ENUM_FONTS);
+    if (efd->total >= efd->size)
+    {
+        efd->size = max( (efd->total + 1) * 2, 256 );
+        efd->lf = heap_realloc( efd->lf, efd->size * sizeof(*efd->lf) );
+        if (!efd->lf) return 0;
+    }
+    efd->lf[efd->total++] = *lf;

return 1;
 }
@@ -3107,10 +3135,13 @@

if (type != TRUETYPE_FONTTYPE) return 1;

-    if (efnd->total < MAX_ENUM_FONTS)
-        efnd->elf[efnd->total++] = *(ENUMLOGFONTA *)lf;
-    else
-        trace("enum tests invalid; you have more than %d fonts\n", MAX_ENUM_FONTS);
+    if (efnd->total >= efnd->size)
+    {
+        efnd->size = max( (efnd->total + 1) * 2, 256 );
+        efnd->elf = heap_realloc( efnd->elf, efnd->size * sizeof(*efnd->elf) );
+        if (!efnd->elf) return 0;
+    }
+    efnd->elf[efnd->total++] = *(ENUMLOGFONTA *)lf;

return 1;
 }
@@ -3144,7 +3175,7 @@
         target.lfCharSet = ANSI_CHARSET;
     }

-    efd.total = 0;
+    memset(&efd, 0, sizeof(efd));
     memset(&enum_font, 0, sizeof(enum_font));
     strcpy(enum_font.lfFaceName, target.lfFaceName);
     enum_font.lfCharSet = DEFAULT_CHARSET;
@@ -3152,15 +3183,14 @@
     ReleaseDC(0, hdc);

trace("'%s' has %d charsets.\n", target.lfFaceName, efd.total);
-    if (efd.total < 2) {
+    if (efd.total < 2)
         ok(0, "EnumFontFamilies is broken. Expected >= 2, got %d.\n", efd.total);
-        return;
-    }
-
-    ok(efd.lf[0].lfCharSet == target.lfCharSet,
-       "(%s) got charset %d expected %d\n",
-       efd.lf[0].lfFaceName, efd.lf[0].lfCharSet, target.lfCharSet);
-
+    else
+        ok(efd.lf[0].lfCharSet == target.lfCharSet,
+           "(%s) got charset %d expected %d\n",
+           efd.lf[0].lfFaceName, efd.lf[0].lfCharSet, target.lfCharSet);
+
+    heap_free(efd.lf);
     return;
 }

@@ -5215,6 +5245,12 @@
     if (type != TRUETYPE_FONTTYPE) return 1;
     if (strcmp(lf->lfFaceName, "MS Shell Dlg") != 0) return 1;

+    if (efnd->total >= efnd->size)
+    {
+        efnd->size = max( (efnd->total + 1) * 2, 256 );
+        efnd->elf = heap_realloc( efnd->elf, efnd->size * sizeof(*efnd->elf) );
+        if (!efnd->elf) return 0;
+    }
     efnd->elf[efnd->total++] = *(ENUMLOGFONTA *)lf;
     return 0;
 }
@@ -5230,6 +5266,12 @@
     if (type != TRUETYPE_FONTTYPE) return 1;
     if (strcmp(lf->lfFaceName, "MS Shell Dlg 2") != 0) return 1;

+    if (efnd->total >= efnd->size)
+    {
+        efnd->size = max( (efnd->total + 1) * 2, 256 );
+        efnd->elf = heap_realloc( efnd->elf, efnd->size * sizeof(*efnd->elf) );
+        if (!efnd->elf) return 0;
+    }
     efnd->elf[efnd->total++] = *(ENUMLOGFONTA *)lf;
     return 0;
 }
@@ -5261,7 +5303,7 @@
     memset(&lf, 0, sizeof(lf));
     lf.lfCharSet = DEFAULT_CHARSET;

-    memset(&efnd, 0, sizeof(efnd));
+    efnd.total = 0;
     strcpy(lf.lfFaceName, "MS Shell Dlg");
     ret = EnumFontFamiliesExA(hdc, &lf, enum_ms_shell_dlg_proc, (LPARAM)&efnd, 0);
     ok(!ret, "MS Shell Dlg should be enumerated\n");
@@ -5271,12 +5313,12 @@
     ret = strcmp((const char *)efnd.elf[0].elfFullName, "MS Shell Dlg");
     ok(ret, "did not expect MS Shell Dlg\n");

-    memset(&efnd, 0, sizeof(efnd));
+    efnd.total = 0;
     ret = EnumFontFamiliesExA(hdc, NULL, enum_ms_shell_dlg2_proc, (LPARAM)&efnd, 0);
     ok(ret, "MS Shell Dlg 2 should not be enumerated\n");
     ok(!efnd.total, "MS Shell Dlg 2 should not be enumerated\n");

-    memset(&efnd, 0, sizeof(efnd));
+    efnd.total = 0;
     strcpy(lf.lfFaceName, "MS Shell Dlg 2");
     ret = EnumFontFamiliesExA(hdc, &lf, enum_ms_shell_dlg2_proc, (LPARAM)&efnd, 0);
     ok(!ret, "MS Shell Dlg 2 should be enumerated\n");
@@ -5286,6 +5328,7 @@
     ret = strcmp((const char *)efnd.elf[0].elfFullName, "MS Shell Dlg 2");
     ok(ret, "did not expect MS Shell Dlg 2\n");

+    heap_free(efnd.elf);
     DeleteDC(hdc);
 }

@@ -5396,7 +5439,7 @@
     lf.lfItalic = FALSE;
     lf.lfWeight = FW_DONTCARE;
     strcpy(lf.lfFaceName, Family);
-    efnd.total = 0;
+    memset(&efnd, 0, sizeof(efnd));
     EnumFontFamiliesExA(hdc, &lf, enum_fullname_data_proc, (LPARAM)&efnd, 0);
     if (efnd.total == 0)
         skip("%s is not installed\n", lf.lfFaceName);
@@ -5477,6 +5520,7 @@
         HeapFree(GetProcessHeap(), 0, bufW);
         HeapFree(GetProcessHeap(), 0, bufA);
     }
+    heap_free(efnd.elf);
     DeleteDC(hdc);
 }

@@ -6225,7 +6269,7 @@
     lf.lfQuality = DEFAULT_QUALITY;
     lf.lfItalic = FALSE;
     lf.lfWeight = FW_DONTCARE;
-    efd.total = 0;
+    memset( &efd, 0, sizeof(efd) );
     EnumFontFamiliesExA(hdc, &lf, enum_font_data_proc, (LPARAM)&efd, 0);
     for (i = 0; i < efd.total; i++)
     {
@@ -6239,6 +6283,7 @@
             }
         }
     }
+    heap_free( efd.lf );
     DeleteDC( hdc );
 }

Modified: trunk/rostests/winetests/gdi32/metafile.c
URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/gdi32/metafile.c...
==============================================================================
--- trunk/rostests/winetests/gdi32/metafile.c	[iso-8859-1] (original)
+++ trunk/rostests/winetests/gdi32/metafile.c	[iso-8859-1] Sun Jul  3 11:29:52 2016
@@ -148,6 +148,13 @@
         ok(!memcmp(&orig_lf, &device_lf, FIELD_OFFSET(LOGFONTA, lfOutPrecision)), "fonts don't match\n");
         ok(!lstrcmpA(orig_lf.lfFaceName, device_lf.lfFaceName), "font names don't match\n");

+        ok(!emr_ExtTextOutW->rclBounds.left, "emr_ExtTextOutW->rclBounds.left = %d\n",
+                emr_ExtTextOutW->rclBounds.left);
+        ok(emr_ExtTextOutW->rclBounds.right != -1, "emr_ExtTextOutW->rclBounds.right = %d\n",
+                emr_ExtTextOutW->rclBounds.right);
+        ok(emr_ExtTextOutW->rclBounds.bottom != -1, "emr_ExtTextOutW->rclBounds.bottom = %d\n",
+                emr_ExtTextOutW->rclBounds.bottom);
+
         for(i = 0; i < emr_ExtTextOutW->emrtext.nChars; i++)
         {
             ok(orig_dx[i] == dx[i], "pass %d: dx[%d] (%d) didn't match %d\n",
@@ -227,6 +234,20 @@

/* 2. pass custom lpDx */
     ret = ExtTextOutA(hdcMetafile, 0, 20, 0, &rc, text, lstrlenA(text), dx);
+    ok( ret, "ExtTextOutA error %d\n", GetLastError());
+
+    /* 3. pass NULL lprc */
+    ret = ExtTextOutA(hdcMetafile, 0, 40, 0, NULL, text, lstrlenA(text), NULL);
+    ok( ret, "ExtTextOutA error %d\n", GetLastError());
+
+    /* 4. test with unmatched BeginPath/EndPath calls */
+    ret = BeginPath(hdcMetafile);
+    ok( ret, "BeginPath error %d\n", GetLastError());
+    ret = BeginPath(hdcMetafile);
+    ok( ret, "BeginPath error %d\n", GetLastError());
+    ret = EndPath(hdcMetafile);
+    ok( ret, "BeginPath error %d\n", GetLastError());
+    ret = ExtTextOutA(hdcMetafile, 0, 60, 0, NULL, text, lstrlenA(text), NULL);
     ok( ret, "ExtTextOutA error %d\n", GetLastError());

hFont = SelectObject(hdcMetafile, hFont);
@@ -989,7 +1010,7 @@
 /* with the nominal results. */

/* Maximum size of sample metafiles in bytes. */
-#define MF_BUFSIZE 512
+#define MF_BUFSIZE 1024

/* 8x8 bitmap data for a pattern brush */
 static const unsigned char SAMPLE_PATTERN_BRUSH[] = {
@@ -1269,16 +1290,16 @@
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x6a, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00,
+    0x4f, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00,
     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
-    0xa0, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x64, 0x02, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x23, 0x04, 0x00, 0x00, 0x3b, 0x02, 0x00, 0x00,
-    0x75, 0x01, 0x00, 0x00, 0xc9, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x08, 0xb1, 0x05, 0x00,
-    0x28, 0x11, 0x03, 0x00, 0x4c, 0x00, 0x00, 0x00,
+    0x80, 0x07, 0x00, 0x00, 0xb0, 0x04, 0x00, 0x00,
+    0xfc, 0x01, 0x00, 0x00, 0x3e, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x60, 0xc0, 0x07, 0x00,
+    0x30, 0xda, 0x04, 0x00, 0x4c, 0x00, 0x00, 0x00,
     0xbc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
     0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -1314,9 +1335,34 @@
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
-    0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
+    0x00, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00,
+    0xc4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x20, 0x00, 0xcc, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0a, 0xd7, 0xa3, 0x3b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0a, 0xd7, 0x23, 0x3c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x6c, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+    0x94, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x90, 0x01, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00
 };

static const unsigned char EMF_DCBRUSH_BITS[] =
@@ -1409,6 +1455,97 @@
     0x14, 0x00, 0x00, 0x00
 };

+static const unsigned char EMF_POLYPOLYLINE_BITS[] =
+{
+    0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x00, 0x90, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00,
+    0x61, 0x01, 0x00, 0x00, 0xc2, 0x02, 0x00, 0x00,
+    0x7a, 0xd4, 0x13, 0x00, 0xe8, 0x44, 0x00, 0x00,
+    0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
+    0x84, 0x01, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xa1, 0x05, 0x00, 0x00, 0x47, 0x03, 0x00, 0x00,
+    0xfc, 0x01, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xc0, 0xc1, 0x07, 0x00,
+    0x2c, 0x84, 0x04, 0x00, 0x5a, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00,
+    0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x14, 0x00,
+    0x5a, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x14, 0x00, 0x64, 0x00, 0xc8, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00,
+    0x00, 0x90, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x00, 0x90, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00,
+    0x00, 0x90, 0x00, 0x00, 0x2c, 0x01, 0x00, 0x00,
+    0x90, 0x01, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00
+};
+
+static const unsigned char EMF_GRADIENTFILL_BITS[] =
+{
+    0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x2b, 0x01, 0x00, 0x00, 0x35, 0x01, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x61, 0x01, 0x00, 0x00,
+    0x31, 0x29, 0x00, 0x00, 0xa3, 0x2a, 0x00, 0x00,
+    0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
+    0x0c, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x40, 0x05, 0x00, 0x00, 0x46, 0x03, 0x00, 0x00,
+    0xda, 0x01, 0x00, 0x00, 0x28, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x15, 0x3c, 0x07, 0x00,
+    0xcb, 0x82, 0x04, 0x00, 0x76, 0x00, 0x00, 0x00,
+    0x8c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x2b, 0x01, 0x00, 0x00,
+    0x35, 0x01, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x00, 0xff, 0x00, 0x80, 0x00, 0x00, 0x01, 0x80,
+    0xc8, 0x00, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff,
+    0xb4, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00,
+    0x34, 0x12, 0x78, 0x56, 0xbc, 0x9a, 0xf0, 0xde,
+    0x2c, 0x01, 0x00, 0x00, 0x36, 0x01, 0x00, 0x00,
+    0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+    0x90, 0x01, 0x00, 0x00, 0x9a, 0x01, 0x00, 0x00,
+    0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00
+};
+
 /* For debugging or dumping the raw metafiles produced by
  * new test functions.
  */
@@ -1757,6 +1894,14 @@
        broken(emh1->nSize - diff_nt4 == emh2->nSize) ||
        broken(emh1->nSize - diff_9x == emh2->nSize),
        "expected nSize %u, got %u\n", emh1->nSize, emh2->nSize);
+    ok(emh1->rclBounds.left == emh2->rclBounds.left, "%s: expected rclBounds.left = %d, got %d\n",
+            desc, emh1->rclBounds.left, emh2->rclBounds.left);
+    ok(emh1->rclBounds.top == emh2->rclBounds.top, "%s: expected rclBounds.top = %d, got %d\n",
+            desc, emh1->rclBounds.top, emh2->rclBounds.top);
+    ok(emh1->rclBounds.right == emh2->rclBounds.right, "%s: expected rclBounds.right = %d, got %d\n",
+            desc, emh1->rclBounds.right, emh2->rclBounds.right);
+    ok(emh1->rclBounds.bottom == emh2->rclBounds.bottom, "%s: expected rclBounds.bottom = %d, got %d\n",
+            desc, emh1->rclBounds.bottom, emh2->rclBounds.bottom);
     ok(emh1->dSignature == emh2->dSignature, "expected dSignature %u, got %u\n", emh1->dSignature, emh2->dSignature);
     ok(emh1->nBytes == emh2->nBytes ||
        broken(emh1->nBytes - diff_nt4 == emh2->nBytes) ||
@@ -1805,6 +1950,7 @@
         0,      /* biClrImportant */
     };
     void *bits;
+    XFORM xform;
     BOOL ret;

hdcDisplay = CreateDCA("DISPLAY", NULL, NULL, NULL);
@@ -1812,6 +1958,7 @@

hdcBitmap = CreateCompatibleDC(hdcDisplay);
     ok( hdcBitmap != 0, "CreateCompatibleDC failed\n" );
+    ok(SetGraphicsMode(hdcBitmap, GM_ADVANCED), "SetGraphicsMode failed\n");
     bmih.biXPelsPerMeter = MulDiv(GetDeviceCaps(hdcDisplay, LOGPIXELSX), 100, 3937);
     bmih.biYPelsPerMeter = MulDiv(GetDeviceCaps(hdcDisplay, LOGPIXELSY), 100, 3937);
     hBitmap = CreateDIBSection(hdcDisplay, (const BITMAPINFO *)&bmih,
@@ -1829,6 +1976,19 @@
     ok( ret, "BitBlt(SRCCOPY) failed\n" );
     ret = BitBlt(hdcMetafile, 0, 0, BMP_DIM, BMP_DIM, 0, 0, 0, WHITENESS);
     ok( ret, "BitBlt(WHITENESS) failed\n" );
+
+    ok(SetMapMode(hdcBitmap, MM_ANISOTROPIC), "SetMapMode failed\n");
+    ok(SetWindowOrgEx(hdcBitmap, 0, 0, NULL), "SetWindowOrgEx failed\n");
+    ok(SetWindowExtEx(hdcBitmap, 400, 400, NULL), "SetWindowExtEx failed\n");
+    ok(SetViewportOrgEx(hdcBitmap, 0, 0, NULL), "SetViewportOrgEx failed\n");
+    ok(SetViewportExtEx(hdcBitmap, BMP_DIM, BMP_DIM, NULL), "SetViewportExtEx failed\n");
+    memset(&xform, 0, sizeof(xform));
+    xform.eM11 = 0.5;
+    xform.eM22 = 1.0;
+    ok(SetWorldTransform(hdcBitmap, &xform), "SetWorldTransform failed\n");
+
+    ret = StretchBlt(hdcMetafile, 0, 0, BMP_DIM, BMP_DIM, hdcBitmap, 0, 0, 400, 400, SRCCOPY);
+    ok( ret, "StretchBlt(SRCCOPY) failed\n" );

hMetafile = CloseEnhMetaFile(hdcMetafile);
     ok( hMetafile != 0, "CloseEnhMetaFile failed\n" );
@@ -2775,6 +2935,63 @@
     DeleteMetaFile(hmf);
     ReleaseDC(hwnd, hdc);
     DestroyWindow(hwnd);
+}
+
+static const unsigned char MF_PATH_BITS[] =
+{
+    0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x2c, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0x02,
+    0x32, 0x00, 0x32, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x13, 0x02, 0x96, 0x00, 0x32, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x13, 0x02, 0x96, 0x00, 0x96, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x13, 0x02, 0x32, 0x00,
+    0x96, 0x00, 0x05, 0x00, 0x00, 0x00, 0x13, 0x02,
+    0x32, 0x00, 0x32, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x1b, 0x04, 0x14, 0x00, 0x14, 0x00, 0x0a, 0x00,
+    0x0a, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static void test_mf_GetPath(void)
+{
+    HDC hdc;
+    HMETAFILE hmf;
+    BOOL ret;
+    int size;
+
+    SetLastError(0xdeadbeef);
+    hdc = CreateMetaFileA(NULL);
+    ok(hdc != 0, "CreateMetaFileA error %d\n", GetLastError());
+
+    ret = BeginPath(hdc);
+    ok(!ret, "BeginPath on metafile DC should fail\n");
+    ret = MoveToEx(hdc, 50, 50, NULL);
+    ok( ret, "MoveToEx error %d.\n", GetLastError());
+    ret = LineTo(hdc, 50, 150);
+    ok( ret, "LineTo error %d.\n", GetLastError());
+    ret = LineTo(hdc, 150, 150);
+    ok( ret, "LineTo error %d.\n", GetLastError());
+    ret = LineTo(hdc, 150, 50);
+    ok( ret, "LineTo error %d.\n", GetLastError());
+    ret = LineTo(hdc, 50, 50);
+    ok( ret, "LineTo error %d.\n", GetLastError());
+    Rectangle(hdc, 10, 10, 20, 20);
+    EndPath(hdc);
+
+    size = GetPath(hdc, NULL, NULL, 0);
+    ok( size == -1, "GetPath returned %d.\n", size);
+
+    hmf = CloseMetaFile(hdc);
+    ok(hmf != 0, "CloseMetaFile error %d\n", GetLastError());
+
+    if (compare_mf_bits (hmf, MF_PATH_BITS, sizeof(MF_PATH_BITS), "mf_GetPath") != 0)
+    {
+        dump_mf_bits(hmf, "mf_GetPath");
+        EnumMetaFile(0, hmf, mf_enum_proc, 0);
+    }
+
+    ret = DeleteMetaFile(hmf);
+    ok( ret, "DeleteMetaFile error %d\n", GetLastError());
 }

static INT CALLBACK EmfEnumProc(HDC hdc, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR, INT nObj, LPARAM lpData)
@@ -3483,16 +3700,16 @@
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0xe6, 0xff, 0xff, 0xff, 0xe6, 0xff, 0xff, 0xff,
+    0xef, 0xff, 0xff, 0xff, 0xea, 0xff, 0xff, 0xff,
     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
-    0xf8, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x0c, 0x02, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x80, 0x07, 0x00, 0x00, 0xd3, 0x03, 0x00, 0x00,
-    0xfc, 0x01, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x60, 0xc0, 0x07, 0x00,
-    0xd3, 0xf3, 0x03, 0x00, 0x3b, 0x00, 0x00, 0x00,
+    0x80, 0x07, 0x00, 0x00, 0x3e, 0x04, 0x00, 0x00,
+    0x40, 0x01, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x04, 0x00,
+    0x80, 0xa9, 0x03, 0x00, 0x3b, 0x00, 0x00, 0x00,
     0x08, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
     0x10, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
     0x32, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
@@ -3506,14 +3723,51 @@
     0x32, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00,
     0x18, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
     0x0a, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
-    0x13, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
-    0x08, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
-    0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x10, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00
+    0x13, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00,
+    0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x0a, 0x00, 0x14, 0x00, 0x0a, 0x00,
+    0x0a, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00,
+    0x5a, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x0a, 0x00, 0x14, 0x00, 0x0a, 0x00,
+    0x0a, 0x00, 0x14, 0x00, 0x14, 0x00, 0x14, 0x00,
+    0x3c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00
 };

static void test_emf_GetPath(void)
 {
+    POINT pts[4] = {{10, 10}, {20, 10}, {10, 20}, {20, 20}};
+    DWORD counts[2] = {2, 2};
     HDC hdcMetafile;
     HENHMETAFILE hemf;
     BOOL ret;
@@ -3523,7 +3777,8 @@
     hdcMetafile = CreateEnhMetaFileA(GetDC(0), NULL, NULL, NULL);
     ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());

-    BeginPath(hdcMetafile);
+    ret = BeginPath(hdcMetafile);
+    ok(ret, "BeginPath error %d\n", GetLastError());
     ret = MoveToEx(hdcMetafile, 50, 50, NULL);
     ok( ret, "MoveToEx error %d.\n", GetLastError());
     ret = LineTo(hdcMetafile, 50, 150);
@@ -3535,10 +3790,17 @@
     ret = LineTo(hdcMetafile, 50, 50);
     ok( ret, "LineTo error %d.\n", GetLastError());
     Rectangle(hdcMetafile, 10, 10, 20, 20);
+    Arc(hdcMetafile, 21, 21, 39, 29, 39, 29, 21, 21);
+    Chord(hdcMetafile, 21, 21, 39, 29, 39, 29, 21, 21);
+    Pie(hdcMetafile, 21, 21, 39, 29, 39, 29, 21, 21);
+    Ellipse(hdcMetafile, 10, 10, 20, 20);
+    RoundRect(hdcMetafile, 10, 10, 20, 20, 3, 5);
+    Polyline(hdcMetafile, pts, 4);
+    PolyPolyline(hdcMetafile, pts, counts, 2);
     EndPath(hdcMetafile);

size = GetPath(hdcMetafile, NULL, NULL, 0);
-    ok( size == 9, "GetPath returned %d.\n", size);
+    todo_wine ok( size == 77, "GetPath returned %d.\n", size);

hemf = CloseEnhMetaFile(hdcMetafile);
     ok(hemf != 0, "CloseEnhMetaFile error %d\n", GetLastError());
@@ -3550,6 +3812,104 @@
     }

DeleteEnhMetaFile(hemf);
+}
+
+static void test_emf_PolyPolyline(void)
+{
+    HDC hdcMetafile;
+    HENHMETAFILE hemf;
+    POINT pts[4] = {{10, 20}, {100, 200}, {0x9000,300}, {400, 500}};
+    DWORD counts[2];
+    BOOL ret;
+
+    SetLastError(0xdeadbeef);
+    hdcMetafile = CreateEnhMetaFileA(GetDC(0), NULL, NULL, NULL);
+    ok(hdcMetafile != 0, "CreateEnhMetaFileA error %d\n", GetLastError());
+
+    ret = PolyPolyline(hdcMetafile, NULL, NULL, 0);
+    ok( !ret, "PolyPolyline\n" );
+
+    SetLastError( 0xdeadbeef );
+    counts[0] = 0;
+    counts[1] = 1;
+    ret = PolyPolyline(hdcMetafile, pts, counts, 2);
+    ok( !ret, "PolyPolyline\n" );
+    ok( GetLastError() == ERROR_INVALID_PARAMETER, "gle %d\n", GetLastError() );
+
+    SetLastError( 0xdeadbeef );
+    counts[0] = 1;
+    counts[1] = 1;
+    ret = PolyPolyline(hdcMetafile, pts, counts, 2);
+    ok( !ret, "PolyPolyline\n" );
+    ok( GetLastError() == ERROR_INVALID_PARAMETER, "gle %d\n", GetLastError() );
+
+    SetLastError( 0xdeadbeef );
+    counts[0] = 2;
+    counts[1] = 1;
+    ret = PolyPolyline(hdcMetafile, pts, counts, 2);
+    ok( !ret, "PolyPolyline\n" );
+    ok( GetLastError() == ERROR_INVALID_PARAMETER, "gle %d\n", GetLastError() );
+
+    counts[0] = 2;
+    counts[1] = 2;
+    ret = PolyPolyline(hdcMetafile, pts, counts, 2);
+    ok( ret, "PolyPolyline\n" );
+
+    hemf = CloseEnhMetaFile(hdcMetafile);
+    ok(hemf != 0, "CloseEnhMetaFile error %d\n", GetLastError());
+
+    if(compare_emf_bits(hemf, EMF_POLYPOLYLINE_BITS, sizeof(EMF_POLYPOLYLINE_BITS),
+        "emf_PolyPolyline", FALSE) != 0)
+    {
+        dump_emf_bits(hemf, "emf_PolyPolyline");
+        dump_emf_records(hemf, "emf_PolyPolyline");
+    }
+
+    DeleteEnhMetaFile(hemf);
+}
+
+static void test_emf_GradientFill(void)
+{
+    HDC mf;
+    HENHMETAFILE hemf;
+    TRIVERTEX v[] =
+    {
+        {   1,  10, 0xff00, 0x8000, 0x0000, 0x8001 },
+        { 200, 210, 0x0000, 0x0000, 0xff00, 0xff00 },
+        { 180, 190, 0x1234, 0x5678, 0x9abc, 0xdef0 },
+        { 300, 310, 0xff00, 0xff00, 0xff00, 0x0000 },
+        { 400, 410, 0xff00, 0xff00, 0xff00, 0x0000 }
+    };
+    GRADIENT_TRIANGLE tri[] = { { 0, 1, 2 }, { 3, 1, 0 } };
+    BOOL ret;
+
+    mf = CreateEnhMetaFileA( GetDC( 0 ), NULL, NULL, NULL );
+    ok( mf != 0, "CreateEnhMetaFileA error %d\n", GetLastError() );
+
+    /* Don't test the GRADIENT_FILL_RECT_ modes since a Windows bug
+     * means it allocates three mesh indices rather than two per
+     * rectangle.  This results in uninitialised values being written
+     * to the EMF which is rather difficult to test against.
+     *
+     * Note also that the final vertex here is not required, yet it is
+     * written to the EMF, but is not considered in the bounds
+     * calculation.
+     */
+    ret = GdiGradientFill( mf, v, sizeof(v) / sizeof(v[0]), tri, sizeof(tri) / sizeof(tri[0]),
+                           GRADIENT_FILL_TRIANGLE );
+    ok( ret, "GradientFill\n" );
+
+    hemf = CloseEnhMetaFile( mf );
+    ok( hemf != 0, "CloseEnhMetaFile error %d\n", GetLastError() );
+
+    if (compare_emf_bits( hemf, EMF_GRADIENTFILL_BITS, sizeof(EMF_GRADIENTFILL_BITS),
+                          "emf_GradientFill", FALSE ) != 0)
+    {
+        dump_emf_bits( hemf, "emf_GradientFill" );
+        dump_emf_records( hemf, "emf_GradientFill" );
+    }
+
+    DeleteEnhMetaFile( hemf );
 }

START_TEST(metafile)
@@ -3566,6 +3926,8 @@
     test_emf_clipping();
     test_emf_polybezier();
     test_emf_GetPath();
+    test_emf_PolyPolyline();
+    test_emf_GradientFill();

/* For win-format metafiles (mfdrv) */
     test_mf_SaveDC();
@@ -3577,6 +3939,7 @@
     test_SetMetaFileBits();
     test_mf_ExtTextOut_on_path();
     test_mf_clipping();
+    test_mf_GetPath();

/* For metafile conversions */
     test_mf_conversions();