dlls/gdiplus/tests/metafile.c

   1 /*
   2  * Unit test suite for metafiles
   3  *
   4  * Copyright (C) 2011 Vincent Povirk for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "windows.h"
  22 #include <stdio.h>
  23 #include "gdiplus.h"
  24 #include "wine/test.h"
  25
  26 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
  27
  28 typedef struct emfplus_record
  29 {
  30     ULONG todo;
  31     ULONG record_type;
  32 } emfplus_record;
  33
  34 typedef struct emfplus_check_state
  35 {
  36     const char *desc;
  37     int count;
  38     const struct emfplus_record *expected;
  39 } emfplus_check_state;
  40
  41 static void check_record(int count, const char *desc, const struct emfplus_record *expected, const struct emfplus_record *actual)
  42 {
  43     ok(expected->record_type == actual->record_type,
  44         "%s.%i: Expected record type 0x%x, got 0x%x\n", desc, count,
  45         expected->record_type, actual->record_type);
  46 }
  47
  48 typedef struct EmfPlusRecordHeader
  49 {
  50     WORD Type;
  51     WORD Flags;
  52     DWORD Size;
  53     DWORD DataSize;
  54 } EmfPlusRecordHeader;
  55
  56 static int CALLBACK enum_emf_proc(HDC hDC, HANDLETABLE *lpHTable, const ENHMETARECORD *lpEMFR,
  57     int nObj, LPARAM lpData)
  58 {
  59     emfplus_check_state *state = (emfplus_check_state*)lpData;
  60     emfplus_record actual;
  61
  62     if (lpEMFR->iType == EMR_GDICOMMENT)
  63     {
  64         const EMRGDICOMMENT *comment = (const EMRGDICOMMENT*)lpEMFR;
  65
  66         if (comment->cbData >= 4 && memcmp(comment->Data, "EMF+", 4) == 0)
  67         {
  68             int offset = 4;
  69
  70             while (offset + sizeof(EmfPlusRecordHeader) <= comment->cbData)
  71             {
  72                 const EmfPlusRecordHeader *record = (const EmfPlusRecordHeader*)&comment->Data[offset];
  73
  74                 ok(record->Size == record->DataSize + sizeof(EmfPlusRecordHeader),
  75                     "%s: EMF+ record datasize %u and size %u mismatch\n", state->desc, record->DataSize, record->Size);
  76
  77                 ok(offset + record->DataSize <= comment->cbData,
  78                     "%s: EMF+ record truncated\n", state->desc);
  79
  80                 if (offset + record->DataSize > comment->cbData)
  81                     return 0;
  82
  83                 if (state->expected[state->count].record_type)
  84                 {
  85                     actual.todo = 0;
  86                     actual.record_type = record->Type;
  87
  88                     check_record(state->count, state->desc, &state->expected[state->count], &actual);
  89
  90                     state->count++;
  91                 }
  92                 else
  93                 {
  94                     ok(0, "%s: Unexpected EMF+ 0x%x record\n", state->desc, record->Type);
  95                 }
  96
  97                 offset += record->Size;
  98             }
  99
 100             ok(offset == comment->cbData, "%s: truncated EMF+ record data?\n", state->desc);
 101
 102             return 1;
 103         }
 104     }
 105
 106     if (state->expected[state->count].record_type)
 107     {
 108         actual.todo = 0;
 109         actual.record_type = lpEMFR->iType;
 110
 111         check_record(state->count, state->desc, &state->expected[state->count], &actual);
 112
 113         state->count++;
 114     }
 115     else
 116     {
 117         ok(0, "%s: Unexpected EMF 0x%x record\n", state->desc, lpEMFR->iType);
 118     }
 119
 120     return 1;
 121 }
 122
 123 static void check_emfplus(HENHMETAFILE hemf, const emfplus_record *expected, const char *desc)
 124 {
 125     emfplus_check_state state;
 126
 127     state.desc = desc;
 128     state.count = 0;
 129     state.expected = expected;
 130
 131     EnumEnhMetaFile(0, hemf, enum_emf_proc, &state, NULL);
 132
 133     ok(expected[state.count].record_type == 0, "%s: Got %i records, expecting more\n", desc, state.count);
 134 }
 135
 136 static BOOL CALLBACK enum_metafile_proc(EmfPlusRecordType record_type, unsigned int flags,
 137     unsigned int dataSize, const unsigned char *pStr, void *userdata)
 138 {
 139     emfplus_check_state *state = (emfplus_check_state*)userdata;
 140     emfplus_record actual;
 141
 142     actual.todo = 0;
 143     actual.record_type = record_type;
 144
 145     if (dataSize == 0)
 146         ok(pStr == NULL, "non-NULL pStr\n");
 147
 148     if (state->expected[state->count].record_type)
 149     {
 150         check_record(state->count, state->desc, &state->expected[state->count], &actual);
 151
 152         state->count++;
 153     }
 154     else
 155     {
 156         ok(0, "%s: Unexpected EMF 0x%x record\n", state->desc, record_type);
 157     }
 158
 159     return TRUE;
 160 }
 161
 162 static void check_metafile(GpMetafile *metafile, const emfplus_record *expected, const char *desc,
 163     const GpPointF *dst_points, const GpRectF *src_rect, Unit src_unit)
 164 {
 165     GpStatus stat;
 166     HDC hdc;
 167     GpGraphics *graphics;
 168     emfplus_check_state state;
 169
 170     state.desc = desc;
 171     state.count = 0;
 172     state.expected = expected;
 173
 174     hdc = CreateCompatibleDC(0);
 175
 176     stat = GdipCreateFromHDC(hdc, &graphics);
 177     expect(Ok, stat);
 178
 179     stat = GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, dst_points,
 180         3, src_rect, src_unit, enum_metafile_proc, &state, NULL);
 181     todo_wine expect(Ok, stat);
 182
 183     todo_wine ok(expected[state.count].record_type == 0, "%s: Got %i records, expecting more\n", desc, state.count);
 184
 185     GdipDeleteGraphics(graphics);
 186
 187     DeleteDC(hdc);
 188 }
 189
 190 static const emfplus_record empty_records[] = {
 191     {0, EMR_HEADER},
 192     {0, EmfPlusRecordTypeHeader},
 193     {0, EmfPlusRecordTypeEndOfFile},
 194     {0, EMR_EOF},
 195     {0}
 196 };
 197
 198 static void test_empty(void)
 199 {
 200     GpStatus stat;
 201     GpMetafile *metafile;
 202     GpGraphics *graphics;
 203     HDC hdc;
 204     HENHMETAFILE hemf, dummy;
 205     BOOL ret;
 206     static const GpRectF frame = {0.0, 0.0, 100.0, 100.0};
 207     static const GpPointF dst_points[3] = {{0.0,0.0},{100.0,0.0},{0.0,100.0}};
 208     static const WCHAR description[] = {'w','i','n','e','t','e','s','t',0};
 209
 210     hdc = CreateCompatibleDC(0);
 211
 212     stat = GdipRecordMetafile(NULL, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
 213     expect(InvalidParameter, stat);
 214
 215     stat = GdipRecordMetafile(hdc, MetafileTypeInvalid, &frame, MetafileFrameUnitPixel, description, &metafile);
 216     expect(InvalidParameter, stat);
 217
 218     stat = GdipRecordMetafile(hdc, MetafileTypeWmf, &frame, MetafileFrameUnitPixel, description, &metafile);
 219     expect(InvalidParameter, stat);
 220
 221     stat = GdipRecordMetafile(hdc, MetafileTypeWmfPlaceable, &frame, MetafileFrameUnitPixel, description, &metafile);
 222     expect(InvalidParameter, stat);
 223
 224     stat = GdipRecordMetafile(hdc, MetafileTypeEmfPlusDual+1, &frame, MetafileFrameUnitPixel, description, &metafile);
 225     expect(InvalidParameter, stat);
 226
 227     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, NULL);
 228     expect(InvalidParameter, stat);
 229
 230     stat = GdipRecordMetafile(hdc, EmfTypeEmfPlusOnly, &frame, MetafileFrameUnitPixel, description, &metafile);
 231     expect(Ok, stat);
 232
 233     DeleteDC(hdc);
 234
 235     if (stat != Ok)
 236         return;
 237
 238     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 239     expect(InvalidParameter, stat);
 240
 241     stat = GdipGetImageGraphicsContext((GpImage*)metafile, &graphics);
 242     expect(Ok, stat);
 243
 244     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 245     expect(InvalidParameter, stat);
 246
 247     stat = GdipDeleteGraphics(graphics);
 248     expect(Ok, stat);
 249
 250     check_metafile(metafile, empty_records, "empty metafile", dst_points, &frame, UnitPixel);
 251
 252     stat = GdipGetHemfFromMetafile(metafile, &hemf);
 253     expect(Ok, stat);
 254
 255     stat = GdipGetHemfFromMetafile(metafile, &dummy);
 256     expect(InvalidParameter, stat);
 257
 258     stat = GdipDisposeImage((GpImage*)metafile);
 259     expect(Ok, stat);
 260
 261     check_emfplus(hemf, empty_records, "empty emf");
 262
 263     ret = DeleteEnhMetaFile(hemf);
 264     ok(ret != 0, "Failed to delete enhmetafile %p\n", hemf);
 265 }
 266
 267 START_TEST(metafile)
 268 {
 269     struct GdiplusStartupInput gdiplusStartupInput;
 270     ULONG_PTR gdiplusToken;
 271
 272     gdiplusStartupInput.GdiplusVersion              = 1;
 273     gdiplusStartupInput.DebugEventCallback          = NULL;
 274     gdiplusStartupInput.SuppressBackgroundThread    = 0;
 275     gdiplusStartupInput.SuppressExternalCodecs      = 0;
 276
 277     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 278
 279     test_empty();
 280
 281     GdiplusShutdown(gdiplusToken);
 282 }