1 #ifdef WIN32
2 #ifndef __cplusplus
3 #error Please compile with a C++ compiler.
4 #endif
5 #endif
6
7 #if defined(USE_WINDOWS_GDIPLUS)
8 #include <Windows.h>
9 #include <GdiPlus.h>
10
11 #pragma comment(lib, "gdiplus")
12 #else
13 #include <GdiPlusFlat.h>
14 #endif
15
16 #if defined(USE_WINDOWS_GDIPLUS)
17 using namespace Gdiplus;
18 using namespace DllExports;
19 #endif
20
21 #include <assert.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include "testhelpers.h"
26
getEmptyHDC()27 static HDC getEmptyHDC ()
28 {
29 #if defined(USE_WINDOWS_GDIPLUS)
30 return CreateCompatibleDC (NULL);
31 #else
32 return (HDC)1;
33 #endif
34 }
35
readFile(const char * fileName,int * memoryLength)36 static void *readFile (const char *fileName, int *memoryLength)
37 {
38 void *buffer = NULL;
39 size_t length;
40 size_t read_length;
41
42 FILE *f = fopen (fileName, "rb");
43 assert (f && "Expected file to exist.");
44
45 fseek (f, 0, SEEK_END);
46 length = ftell (f);
47
48 fseek (f, 0, SEEK_SET);
49 buffer = malloc (length);
50 assert (buffer && "Expected successful allocation of buffer.");
51
52 read_length = fread (buffer, 1, length, f);
53 assert (read_length && "Expected successful read.");
54 fclose (f);
55
56 *memoryLength = (int) length;
57 return buffer;
58 }
59
verifyFont(GpFont * font,GpFontFamily * originalFamily,INT expectedStyle,Unit expectedUnit)60 static void verifyFont (GpFont *font, GpFontFamily *originalFamily, INT expectedStyle, Unit expectedUnit)
61 {
62 GpStatus status;
63 GpFontFamily *family;
64 WCHAR originalFamilyName[LF_FACESIZE];
65 WCHAR familyName[LF_FACESIZE];
66 Unit unit;
67 INT style;
68
69 assert (font && "Expected font to be initialized.");
70
71 status = GdipGetFamily (font, &family);
72 assertEqualInt (status, Ok);
73 assert (family && family != originalFamily);
74
75 status = GdipGetFamilyName (originalFamily, originalFamilyName, 0);
76 assertEqualInt (status, Ok);
77
78 status = GdipGetFamilyName (family, familyName, 0);
79 assertEqualInt (status, Ok);
80 assert (!strcmp ((char *) originalFamilyName, (char *) familyName));
81
82 status = GdipGetFontUnit (font, &unit);
83 assertEqualInt (status, Ok);
84 assertEqualInt (unit, expectedUnit);
85
86 status = GdipGetFontStyle(font, &style);
87 assertEqualInt (status, Ok);
88 assertEqualInt (style, expectedStyle);
89
90 GdipDeleteFontFamily (family);
91 }
92
test_newPrivateFontCollection()93 static void test_newPrivateFontCollection ()
94 {
95 GpStatus status;
96 GpFontCollection *collection;
97 INT count;
98
99 status = GdipNewPrivateFontCollection (&collection);
100 assertEqualInt (status, Ok);
101
102 status = GdipGetFontCollectionFamilyCount (collection, &count);
103 assertEqualInt (status, Ok);
104 assertEqualInt (count, 0);
105
106 // Negative tests.
107 status = GdipNewPrivateFontCollection (NULL);
108 assertEqualInt (status, InvalidParameter);
109
110 GdipDeletePrivateFontCollection (&collection);
111 }
112
test_deletePrivateFontCollection()113 static void test_deletePrivateFontCollection ()
114 {
115 GpStatus status;
116 GpFontCollection *collection;
117
118 GdipNewPrivateFontCollection(&collection);
119
120 status = GdipDeletePrivateFontCollection (&collection);
121 assertEqualInt (status, Ok);
122 assert (!collection && "Expected the pointer to be set to NULL.");
123
124 // Negative tests.
125 status = GdipDeletePrivateFontCollection (NULL);
126 assertEqualInt (status, InvalidParameter);
127 }
128
test_getFontCollectionFamilyCount()129 static void test_getFontCollectionFamilyCount ()
130 {
131 GpStatus status;
132 GpFontCollection *collection;
133 INT count;
134
135 GdipNewPrivateFontCollection(&collection);
136
137 // Negative tests.
138 status = GdipGetFontCollectionFamilyCount (NULL, &count);
139 assertEqualInt (status, InvalidParameter);
140
141 status = GdipGetFontCollectionFamilyCount (collection, NULL);
142 assertEqualInt (status, InvalidParameter);
143
144 GdipDeletePrivateFontCollection (&collection);
145 }
146
test_getFontCollectionFamilyList()147 static void test_getFontCollectionFamilyList ()
148 {
149 GpStatus status;
150 WCHAR *fontFile;
151 GpFontCollection *collection;
152 GpFontFamily *families[2] = {NULL, NULL};
153 INT numFound;
154
155 fontFile = createWchar ("test.ttf");
156 GdipNewPrivateFontCollection(&collection);
157
158 //Empty list.
159 status = GdipGetFontCollectionFamilyList (collection, 10, families, &numFound);
160 assertEqualInt (status, Ok);
161 assertEqualInt (numFound, 0);
162
163 status = GdipGetFontCollectionFamilyList (collection, 0, families, &numFound);
164 assertEqualInt (status, Ok);
165 assertEqualInt (numFound, 0);
166
167 status = GdipGetFontCollectionFamilyList (collection, -1, families, &numFound);
168 assertEqualInt (status, Ok);
169 assertEqualInt (numFound, 0);
170
171 // Non empty list.
172 GdipPrivateAddFontFile (collection, fontFile);
173 status = GdipGetFontCollectionFamilyList (collection, 0, families, &numFound);
174 assertEqualInt (status, Ok);
175 assertEqualInt (numFound, 0);
176 assert (families[0] == NULL);
177 assert (families[1] == NULL);
178
179 // Negative tests.
180 status = GdipGetFontCollectionFamilyList (NULL, 10, families, &numFound);
181 assertEqualInt (status, InvalidParameter);
182
183 status = GdipGetFontCollectionFamilyList (collection, 10, NULL, &numFound);
184 assertEqualInt (status, InvalidParameter);
185
186 status = GdipGetFontCollectionFamilyList (collection, 10, families, NULL);
187 assertEqualInt (status, InvalidParameter);
188
189 GdipDeletePrivateFontCollection (&collection);
190 freeWchar (fontFile);
191 }
192
test_privateAddFontFile()193 static void test_privateAddFontFile ()
194 {
195 GpStatus status;
196 GpFontCollection *collection;
197 WCHAR *ttfFile;
198 WCHAR *otfFile;
199 WCHAR *invalidFile;
200 WCHAR *noSuchFile;
201 INT count;
202 GpFontFamily *families[1];
203 INT numFound;
204 WCHAR name[LF_FACESIZE];
205
206 GdipNewPrivateFontCollection (&collection);
207 ttfFile = createWchar ("test.ttf");
208 otfFile = createWchar ("test.otf");
209 invalidFile = createWchar ("test.bmp");
210 noSuchFile = createWchar ("noSuchFile.ttf");
211
212 // Valid TTF file.
213 status = GdipPrivateAddFontFile (collection, ttfFile);
214 assertEqualInt (status, Ok);
215
216 status = GdipGetFontCollectionFamilyCount (collection, &count);
217 assertEqualInt (status, Ok);
218 assertEqualInt (count, 1);
219
220 status = GdipGetFontCollectionFamilyList (collection, 2, families, &numFound);
221 assertEqualInt (status, Ok);
222 assertEqualInt (numFound, 1);
223
224 status = GdipGetFamilyName (families[0], name, 0);
225 assertEqualInt (status, Ok);
226 assert (stringsEqual (name, "Code New Roman"));
227
228 GdipDeletePrivateFontCollection (&collection);
229
230 // Valid OTF file.
231 GdipNewPrivateFontCollection (&collection);
232
233 status = GdipPrivateAddFontFile (collection, otfFile);
234 assertEqualInt (status, Ok);
235
236 status = GdipGetFontCollectionFamilyCount (collection, &count);
237 assertEqualInt (status, Ok);
238 assertEqualInt (count, 1);
239
240 status = GdipGetFontCollectionFamilyList (collection, 2, families, &numFound);
241 assertEqualInt (status, Ok);
242 assertEqualInt (numFound, 1);
243
244 status = GdipGetFamilyName (families[0], name, 0);
245 assertEqualInt (status, Ok);
246 assert (stringsEqual (name, "Code New Roman"));
247
248 GdipDeletePrivateFontCollection (&collection);
249
250 // Invalid file.
251 GdipNewPrivateFontCollection (&collection);
252
253 status = GdipPrivateAddFontFile (collection, invalidFile);
254 assertEqualInt (status, Ok);
255
256 status = GdipGetFontCollectionFamilyCount (collection, &count);
257 assertEqualInt (status, Ok);
258 assertEqualInt (count, 0);
259
260 // Negative tests.
261 status = GdipPrivateAddFontFile (NULL, ttfFile);
262 assertEqualInt (status, InvalidParameter);
263
264 status = GdipPrivateAddFontFile (collection, NULL);
265 assertEqualInt (status, InvalidParameter);
266
267 status = GdipPrivateAddFontFile (collection, noSuchFile);
268 assertEqualInt (status, FileNotFound);
269
270 GdipDeletePrivateFontCollection (&collection);
271 freeWchar (ttfFile);
272 freeWchar (otfFile);
273 freeWchar (invalidFile);
274 freeWchar (noSuchFile);
275 }
276
test_privateAddMemoryFont()277 static void test_privateAddMemoryFont ()
278 {
279 GpStatus status;
280 GpFontCollection *collection;
281 void *memory;
282 INT memoryLength;
283 long invalidMemory = 1;
284 INT count;
285 GpFontFamily *families[1];
286 INT numFound;
287 WCHAR name[LF_FACESIZE];
288
289 GdipNewPrivateFontCollection (&collection);
290 memory = readFile ("test.ttf", &memoryLength);
291
292 // Valid TTF file.
293 status = GdipPrivateAddMemoryFont (collection, memory, memoryLength);
294 assertEqualInt (status, Ok);
295
296 status = GdipGetFontCollectionFamilyCount (collection, &count);
297 assertEqualInt (status, Ok);
298 assertEqualInt (count, 1);
299
300 status = GdipGetFontCollectionFamilyList (collection, 2, families, &numFound);
301 assertEqualInt (status, Ok);
302 assertEqualInt (numFound, 1);
303
304 status = GdipGetFamilyName (families[0], name, 0);
305 assertEqualInt (status, Ok);
306 assert (stringsEqual (name, "Code New Roman"));
307
308 free (memory);
309 GdipDeletePrivateFontCollection (&collection);
310
311 // Valid OTF file.
312 GdipNewPrivateFontCollection (&collection);
313 memory = readFile ("test.otf", &memoryLength);
314
315 status = GdipPrivateAddMemoryFont (collection, memory, memoryLength);
316 assertEqualInt (status, Ok);
317
318 status = GdipGetFontCollectionFamilyCount (collection, &count);
319 assertEqualInt (status, Ok);
320 assertEqualInt (count, 1);
321
322 status = GdipGetFontCollectionFamilyList (collection, 2, families, &numFound);
323 assertEqualInt (status, Ok);
324 assertEqualInt (numFound, 1);
325
326 status = GdipGetFamilyName (families[0], name, 0);
327 assertEqualInt (status, Ok);
328 assert (stringsEqual (name, "Code New Roman"));
329
330 free (memory);
331 GdipDeletePrivateFontCollection (&collection);
332
333 // Invalid memory is ignored.
334 GdipNewPrivateFontCollection (&collection);
335
336 status = GdipPrivateAddMemoryFont (collection, &invalidMemory, 1);
337 assertEqualInt (status, Ok);
338
339 status = GdipGetFontCollectionFamilyCount (collection, &count);
340 assertEqualInt (status, Ok);
341 assertEqualInt (count, 0);
342
343 // Negative tests.
344 status = GdipPrivateAddMemoryFont (NULL, &invalidMemory, 1);
345 assertEqualInt (status, InvalidParameter);
346
347 status = GdipPrivateAddMemoryFont (collection, NULL, 1);
348 assertEqualInt (status, InvalidParameter);
349
350 status = GdipPrivateAddMemoryFont (collection, &invalidMemory, -1);
351 assertEqualInt (status, InvalidParameter);
352
353 status = GdipPrivateAddMemoryFont (collection, &invalidMemory, 0);
354 assertEqualInt (status, InvalidParameter);
355
356 GdipDeletePrivateFontCollection (&collection);
357 }
358
test_newInstalledFontCollection()359 static void test_newInstalledFontCollection ()
360 {
361 GpStatus status;
362 GpFontCollection *collection1;
363 GpFontCollection *collection2;
364 INT count1;
365 INT count2;
366
367 status = GdipNewInstalledFontCollection (&collection1);
368 assertEqualInt (status, Ok);
369 assert (collection1 && "Expected collection to be initialized.");
370
371 status = GdipGetFontCollectionFamilyCount (collection1, &count1);
372 assertEqualInt (status, Ok);
373 assert (count1 >= 0);
374
375 status = GdipNewInstalledFontCollection (&collection2);
376 assertEqualInt (status, Ok);
377 assert (collection1 == collection2 && "Expected the FontCollecion to be a singleton.");
378
379 status = GdipGetFontCollectionFamilyCount (collection2, &count2);
380 assertEqualInt (status, Ok);
381 assert (count1 == count2 && "Expected the FontCollection count to remain constant over multiple calls.");
382 }
383
test_createFontFromDC()384 static void test_createFontFromDC ()
385 {
386 GpStatus status;
387 GpFont *font;
388 HDC hdc;
389
390 hdc = getEmptyHDC ();
391
392 // Negative tests.
393 status = GdipCreateFontFromDC (NULL, &font);
394 assertEqualInt (status, InvalidParameter);
395
396 // This causes a null pointer dereference in GDI+.
397 #if !defined(USE_WINDOWS_GDIPLUS)
398 status = GdipCreateFontFromDC (hdc, NULL);
399 assertEqualInt (status, InvalidParameter);
400 #endif
401 }
402
403
test_createFontFromLogfontA()404 static void test_createFontFromLogfontA ()
405 {
406 GpStatus status;
407 GpFont *font;
408 LOGFONTA logfont;
409 HDC hdc;
410 GpFontFamily *nativeFamily;
411 WCHAR nativeFamilyNameW[LF_FACESIZE];
412 char *nativeFamilyNameA;
413 INT style;
414 Unit unit;
415 GpFontFamily *family;
416 WCHAR familyName[LF_FACESIZE];
417
418 hdc = getEmptyHDC ();
419 GdipGetGenericFontFamilySansSerif (&nativeFamily);
420 GdipGetFamilyName (nativeFamily, nativeFamilyNameW, 0);
421 nativeFamilyNameA = charFromWchar (nativeFamilyNameW);
422
423 logfont.lfHeight = 10;
424 logfont.lfWidth = 11;
425 logfont.lfEscapement = 0;
426 logfont.lfOrientation = 1;
427 logfont.lfWeight = 700;
428 logfont.lfItalic = TRUE;
429 logfont.lfUnderline = TRUE;
430 logfont.lfStrikeOut = TRUE;
431 logfont.lfCharSet = 0;
432 logfont.lfOutPrecision = 1;
433 logfont.lfClipPrecision = 2;
434 logfont.lfQuality = 4;
435 logfont.lfPitchAndFamily = 0x50;
436 strcpy (logfont.lfFaceName, nativeFamilyNameA);
437
438 status = GdipCreateFontFromLogfontA (hdc, &logfont, &font);
439 assertEqualInt (status, Ok);
440
441 GdipGetFontStyle (font, &style);
442 assertEqualInt (style, 15);
443
444 GdipGetFontUnit(font, &unit);
445 assertEqualInt (unit, UnitWorld);
446
447 status = GdipGetFamily (font, &family);
448 assertEqualInt (status, Ok);
449 GdipGetFamilyName (family, familyName, 0);
450 assert (stringsEqual (familyName, nativeFamilyNameA));
451
452 // Negative tests.
453 status = GdipCreateFontFromLogfontA (NULL, &logfont, &font);
454 assertEqualInt (status, InvalidParameter);
455
456 status = GdipCreateFontFromLogfontA (hdc, NULL, &font);
457 assertEqualInt (status, InvalidParameter);
458
459 // This causes a null pointer dereference in GDI+.
460 #if !defined(USE_WINDOWS_GDIPLUS)
461 status = GdipCreateFontFromLogfontA (hdc, &logfont, NULL);
462 assertEqualInt (status, InvalidParameter);
463 #endif
464
465 GdipDeleteFont (font);
466 GdipDeleteFontFamily (family);
467 GdipDeleteFontFamily (nativeFamily);
468 freeChar (nativeFamilyNameA);
469 }
470
test_createFontFromLogfontW()471 static void test_createFontFromLogfontW ()
472 {
473 GpStatus status;
474 GpFont *font;
475 LOGFONTW logfont;
476 HDC hdc;
477 GpFontFamily *nativeFamily;
478 WCHAR nativeFamilyNameW[LF_FACESIZE];
479 char *nativeFamilyNameA;
480 INT style;
481 Unit unit;
482 GpFontFamily *family;
483 WCHAR familyName[LF_FACESIZE];
484
485 hdc = getEmptyHDC ();
486 GdipGetGenericFontFamilySansSerif (&nativeFamily);
487 GdipGetFamilyName (nativeFamily, nativeFamilyNameW, 0);
488 nativeFamilyNameA = charFromWchar (nativeFamilyNameW);
489
490 logfont.lfHeight = 10;
491 logfont.lfWidth = 11;
492 logfont.lfEscapement = 0;
493 logfont.lfOrientation = 1;
494 logfont.lfWeight = 700;
495 logfont.lfItalic = TRUE;
496 logfont.lfUnderline = TRUE;
497 logfont.lfStrikeOut = TRUE;
498 logfont.lfCharSet = 0;
499 logfont.lfOutPrecision = 1;
500 logfont.lfClipPrecision = 2;
501 logfont.lfQuality = 4;
502 logfont.lfPitchAndFamily = 0x50;
503 memcpy ((void *) logfont.lfFaceName, (void *) nativeFamilyNameW, LF_FACESIZE * sizeof (WCHAR));
504
505 status = GdipCreateFontFromLogfontW (hdc, &logfont, &font);
506 assertEqualInt (status, Ok);
507
508 GdipGetFontStyle (font, &style);
509 assertEqualInt (style, 15);
510
511 GdipGetFontUnit(font, &unit);
512 assertEqualInt (unit, UnitWorld);
513
514 status = GdipGetFamily (font, &family);
515 assertEqualInt (status, Ok);
516 GdipGetFamilyName (family, familyName, 0);
517 assertEqualString (familyName, nativeFamilyNameA);
518
519 // Negative tests.
520 status = GdipCreateFontFromLogfontW (NULL, &logfont, &font);
521 assertEqualInt (status, InvalidParameter);
522
523 status = GdipCreateFontFromLogfontW (hdc, NULL, &font);
524 assertEqualInt (status, InvalidParameter);
525
526 // This causes a null pointer dereference in GDI+.
527 #if !defined(USE_WINDOWS_GDIPLUS)
528 status = GdipCreateFontFromLogfontW (hdc, &logfont, NULL);
529 assertEqualInt (status, InvalidParameter);
530 #endif
531
532 GdipDeleteFont (font);
533 GdipDeleteFontFamily (family);
534 GdipDeleteFontFamily (nativeFamily);
535 freeChar (nativeFamilyNameA);
536 }
537
test_createFont()538 static void test_createFont ()
539 {
540 GpStatus status;
541 GpFont *font;
542 GpFontFamily *family;
543
544 GdipGetGenericFontFamilySansSerif (&family);
545
546 // UnitPixel.
547 status = GdipCreateFont (family, 10, 10, UnitPixel, &font);
548 assertEqualInt (status, Ok);
549 verifyFont (font, family, 10, UnitPixel);
550
551 // Negative tests.
552 status = GdipCreateFont (NULL, 10, 10, UnitPixel, &font);
553 assertEqualInt (status, InvalidParameter);
554
555 status = GdipCreateFont (family, 10, 10, UnitPixel, NULL);
556 assertEqualInt (status, InvalidParameter);
557
558 status = GdipCreateFont (family, -1, 10, UnitPixel, &font);
559 assertEqualInt (status, InvalidParameter);
560
561 status = GdipCreateFont (family, 0, 10, UnitPixel, &font);
562 assertEqualInt (status, InvalidParameter);
563
564 status = GdipCreateFont (family, 10, 10, UnitDisplay, &font);
565 assertEqualInt (status, InvalidParameter);
566
567 status = GdipCreateFont (family, 10, 10, (Unit)(UnitWorld - 1), &font);
568 assertEqualInt (status, InvalidParameter);
569
570 #if defined(USE_WINDOWS_GDIPLUS)
571 status = GdipCreateFont (family, 10, 10, (Unit)(UnitMillimeter + 1), &font);
572 assertEqualInt (status, InvalidParameter);
573 #else
574 status = GdipCreateFont (family, 10, 10, (Unit)(UnitCairoPoint + 1), &font);
575 assertEqualInt (status, InvalidParameter);
576 #endif
577
578 GdipDeleteFont (font);
579 GdipDeleteFontFamily (family);
580 }
581
test_cloneFont()582 static void test_cloneFont ()
583 {
584 GpStatus status;
585 GpFontFamily *family;
586 GpFont *font;
587 GpFont *clonedFont;
588
589 GdipGetGenericFontFamilySansSerif (&family);
590 GdipCreateFont (family, 10, 10, UnitPixel, &font);
591
592 status = GdipCloneFont (font, &clonedFont);
593 assertEqualInt (status, Ok);
594 assert (clonedFont && font != clonedFont);
595 verifyFont (clonedFont, family, 10, UnitPixel);
596
597 // Negative tests.
598 status = GdipCloneFont (NULL, &clonedFont);
599 assertEqualInt (status, InvalidParameter);
600
601 status = GdipCloneFont (font, NULL);
602 assertEqualInt (status, InvalidParameter);
603
604 GdipDeleteFont (font);
605 GdipDeleteFont (clonedFont);
606 }
607
test_deleteFont()608 static void test_deleteFont ()
609 {
610 GpStatus status;
611 GpFontFamily *family;
612 GpFont *font;
613
614 GdipGetGenericFontFamilySansSerif (&family);
615
616 GdipCreateFont (family, 10, 10, UnitPixel, &font);
617
618 status = GdipDeleteFont (font);
619 assertEqualInt (status, Ok);
620
621 // Negative tests.
622 status = GdipDeleteFont (NULL);
623 assertEqualInt (status, InvalidParameter);
624
625 GdipDeleteFontFamily (family);
626 }
627
test_getFamily()628 static void test_getFamily ()
629 {
630 GpStatus status;
631 GpFontFamily *originalFamily;
632 GpFont *font;
633 GpFontFamily *family;
634
635 GdipGetGenericFontFamilySansSerif (&originalFamily);
636 GdipCreateFont (originalFamily, 10, 10, UnitPixel, &font);
637
638 // Negative tests.
639 status = GdipGetFamily (NULL, &family);
640 assertEqualInt (status, InvalidParameter);
641
642 status = GdipGetFamily (font, NULL);
643 assertEqualInt (status, InvalidParameter);
644
645 GdipDeleteFont (font);
646 GdipDeleteFontFamily (originalFamily);
647 }
648
test_getFontStyle()649 static void test_getFontStyle ()
650 {
651 GpStatus status;
652 GpFontFamily *originalFamily;
653 GpFont *font;
654 INT style;
655
656 GdipGetGenericFontFamilySansSerif (&originalFamily);
657 GdipCreateFont (originalFamily, 10, 10, UnitPixel, &font);
658
659 // Negative tests.
660 status = GdipGetFontStyle (NULL, &style);
661 assertEqualInt (status, InvalidParameter);
662
663 status = GdipGetFontStyle (font, NULL);
664 assertEqualInt (status, InvalidParameter);
665
666 GdipDeleteFont (font);
667 GdipDeleteFontFamily (originalFamily);
668 }
669
test_getFontSize()670 static void test_getFontSize ()
671 {
672 GpStatus status;
673 GpFontFamily *originalFamily;
674 GpFont *font;
675 REAL size;
676
677 GdipGetGenericFontFamilySansSerif (&originalFamily);
678 GdipCreateFont (originalFamily, 10, 10, UnitPixel, &font);
679
680 status = GdipGetFontSize (font, &size);
681 assertEqualInt (status, Ok);
682
683 // Negative tests.
684 status = GdipGetFontSize (NULL, &size);
685 assertEqualInt (status, InvalidParameter);
686
687 status = GdipGetFontSize (font, NULL);
688 assertEqualInt (status, InvalidParameter);
689
690 GdipDeleteFont (font);
691 GdipDeleteFontFamily (originalFamily);
692 }
693
test_getFontUnit()694 static void test_getFontUnit ()
695 {
696 GpStatus status;
697 GpFontFamily *originalFamily;
698 GpFont *font;
699 Unit unit;
700
701 GdipGetGenericFontFamilySansSerif (&originalFamily);
702 GdipCreateFont (originalFamily, 10, 10, UnitPixel, &font);
703
704 // Negative tests.
705 status = GdipGetFontUnit (NULL, &unit);
706 assertEqualInt (status, InvalidParameter);
707
708 status = GdipGetFontUnit (font, NULL);
709 assertEqualInt (status, InvalidParameter);
710
711 GdipDeleteFont (font);
712 GdipDeleteFontFamily (originalFamily);
713 }
714
test_getFontHeight()715 static void test_getFontHeight ()
716 {
717 GpStatus status;
718 GpFontFamily *originalFamily;
719 GpFont *font;
720 REAL height;
721
722 GdipGetGenericFontFamilySansSerif (&originalFamily);
723 GdipCreateFont (originalFamily, 10, 10, UnitPixel, &font);
724
725 status = GdipGetFontHeight (font, NULL, &height);
726 assertEqualInt (status, Ok);
727 // FIXME: this returns a different value with libgdiplus.
728 #if defined(USE_WINDOWS_GDIPLUS)
729 assertEqualFloat (height, 11.3183594f);
730 #endif
731
732 // Negative tests.
733 status = GdipGetFontHeight (NULL, NULL, &height);
734 assertEqualInt (status, InvalidParameter);
735
736 status = GdipGetFontHeight (font, NULL, NULL);
737 assertEqualInt (status, InvalidParameter);
738
739 GdipDeleteFont (font);
740 GdipDeleteFontFamily (originalFamily);
741 }
742
test_getFontHeightGivenDPI()743 static void test_getFontHeightGivenDPI ()
744 {
745 GpStatus status;
746 GpFontFamily *originalFamily;
747 GpFont *font;
748 REAL height;
749
750 GdipGetGenericFontFamilySansSerif (&originalFamily);
751 GdipCreateFont (originalFamily, 10, 10, UnitPixel, &font);
752
753 status = GdipGetFontHeightGivenDPI (font, 10, &height);
754 assertEqualInt (status, Ok);
755 // FIXME: this returns a different value with libgdiplus.
756 #if defined(USE_WINDOWS_GDIPLUS)
757 assertEqualFloat (height, 11.3183594f);
758 #endif
759
760 // Negative tests.
761 status = GdipGetFontHeightGivenDPI (NULL, 10, &height);
762 assertEqualInt (status, InvalidParameter);
763
764 status = GdipGetFontHeightGivenDPI (font, 10, NULL);
765 assertEqualInt (status, InvalidParameter);
766
767 GdipDeleteFont (font);
768 GdipDeleteFontFamily (originalFamily);
769 }
770
test_getLogfontA()771 static void test_getLogfontA ()
772 {
773 GpStatus status;
774 GpBitmap *image;
775 GpGraphics *graphics;
776 GpFontFamily *originalFamily;
777 WCHAR originalFamilyName[32];
778 GpFont *font;
779 LOGFONTA logfont;
780
781 GdipCreateBitmapFromScan0 (100, 68, 0, PixelFormat32bppRGB, NULL, &image);
782 GdipGetImageGraphicsContext (image, &graphics);
783 GdipGetGenericFontFamilySansSerif (&originalFamily);
784 GdipCreateFont (originalFamily, 10, 10, UnitPixel, &font);
785 GdipGetFamilyName (originalFamily, originalFamilyName, 0);
786
787 status = GdipGetLogFontA (font, graphics, &logfont);
788 assertEqualInt (status, Ok);
789 assertEqualInt (logfont.lfHeight, -10);
790 assertEqualInt (logfont.lfWidth, 0);
791 assertEqualInt (logfont.lfEscapement, 0);
792 assertEqualInt (logfont.lfOrientation, 0);
793 assertEqualInt (logfont.lfWeight, 400);
794 assertEqualInt (logfont.lfCharSet, 0);
795 assertEqualInt (logfont.lfOutPrecision, 0);
796 assertEqualInt (logfont.lfClipPrecision, 0);
797 assertEqualInt (logfont.lfQuality, 0);
798 assertEqualInt (logfont.lfPitchAndFamily, 0);
799 assert (stringsEqual (originalFamilyName, logfont.lfFaceName));
800
801 // Negative tests.
802 status = GdipGetLogFontA (NULL, graphics, &logfont);
803 assertEqualInt (status, InvalidParameter);
804
805 status = GdipGetLogFontA (font, NULL, &logfont);
806 assertEqualInt (status, InvalidParameter);
807
808 status = GdipGetLogFontA (font, graphics, NULL);
809 assertEqualInt (status, InvalidParameter);
810
811 GdipDeleteFont (font);
812 GdipDeleteFontFamily (originalFamily);
813 GdipDisposeImage ((GpImage *) image);
814 }
815
test_getLogfontW()816 static void test_getLogfontW ()
817 {
818 GpStatus status;
819 GpBitmap *image;
820 GpGraphics *graphics;
821 GpFontFamily *originalFamily;
822 WCHAR originalFamilyName[32];
823 GpFont *font;
824 LOGFONTW logfont;
825
826 GdipCreateBitmapFromScan0 (100, 68, 0, PixelFormat32bppRGB, NULL, &image);
827 GdipGetImageGraphicsContext (image, &graphics);
828 GdipGetGenericFontFamilySansSerif (&originalFamily);
829 GdipCreateFont (originalFamily, 10, 10, UnitPixel, &font);
830 GdipGetFamilyName (originalFamily, originalFamilyName, 0);
831
832 status = GdipGetLogFontW (font, graphics, &logfont);
833 assertEqualInt (status, Ok);
834 assertEqualInt (logfont.lfHeight, -10);
835 assertEqualInt (logfont.lfWidth, 0);
836 assertEqualInt (logfont.lfEscapement, 0);
837 assertEqualInt (logfont.lfOrientation, 0);
838 assertEqualInt (logfont.lfWeight, 400);
839 assertEqualInt (logfont.lfCharSet, 0);
840 assertEqualInt (logfont.lfOutPrecision, 0);
841 assertEqualInt (logfont.lfClipPrecision, 0);
842 assertEqualInt (logfont.lfQuality, 0);
843 assertEqualInt (logfont.lfPitchAndFamily, 0);
844 assert (!strcmp ((char *) originalFamilyName, (char *) logfont.lfFaceName));
845
846 // Negative tests.
847 status = GdipGetLogFontW (NULL, graphics, &logfont);
848 assertEqualInt (status, InvalidParameter);
849
850 status = GdipGetLogFontW (font, NULL, &logfont);
851 assertEqualInt (status, InvalidParameter);
852
853 status = GdipGetLogFontW (font, graphics, NULL);
854 assertEqualInt (status, InvalidParameter);
855
856 GdipDeleteFont (font);
857 GdipDeleteFontFamily (originalFamily);
858 GdipDisposeImage ((GpImage *) image);
859 }
860
861 static const WCHAR Tahoma[] = {'T', 'a', 'h', 'o', 'm', 'a', 0};
862 static const WCHAR CodeNewRoman[] = {'C', 'o', 'd', 'e', ' ', 'N', 'e', 'w', ' ', 'R', 'o', 'm', 'a', 'n', 0};
863 static const WCHAR NoSuchFont[] = {'A', 'B', 'C', 0};
864
verifyFontFamily(GpFontFamily * family,const char * expectedName,UINT16 expectedCellAscent,UINT16 expectedCellDescent,UINT16 expectedLineSpacing,const char * alternateExpectedName,UINT16 alternateCellAscent,UINT16 alternateCellDescent,UINT16 alternateLineSpacing)865 static void verifyFontFamily (GpFontFamily *family, const char *expectedName, UINT16 expectedCellAscent, UINT16 expectedCellDescent, UINT16 expectedLineSpacing, const char *alternateExpectedName, UINT16 alternateCellAscent, UINT16 alternateCellDescent, UINT16 alternateLineSpacing)
866 {
867 GpStatus status;
868 WCHAR name[LF_FACESIZE];
869 UINT16 emHeight;
870 UINT16 cellAscent;
871 UINT16 cellDescent;
872 UINT16 lineSpacing;
873
874 status = GdipGetFamilyName (family, name, 1);
875 assertEqualInt (status, Ok);
876 assert (stringsEqual (name, expectedName) || stringsEqual (name, alternateExpectedName));
877
878 status = GdipGetEmHeight (family, FontStyleRegular, &emHeight);
879 assertEqualInt (status, Ok);
880 assertEqualInt (emHeight, 2048);
881
882 status = GdipGetCellAscent (family, FontStyleRegular, &cellAscent);
883 assertEqualInt (status, Ok);
884 assert (cellAscent == expectedCellAscent || cellAscent == alternateCellAscent);
885
886 status = GdipGetCellDescent (family, FontStyleRegular, &cellDescent);
887 assertEqualInt (status, Ok);
888 assert (cellDescent == expectedCellDescent || cellDescent == alternateCellDescent);
889
890 status = GdipGetLineSpacing (family, FontStyleRegular, &lineSpacing);
891 assertEqualInt (status, Ok);
892 assert (lineSpacing == expectedLineSpacing || lineSpacing == alternateLineSpacing);
893
894 GdipDeleteFontFamily (family);
895 }
896
test_createFontFamilyFromName()897 static void test_createFontFamilyFromName ()
898 {
899 GpStatus status;
900 GpFontFamily *family;
901 GpFontCollection *collection;
902 WCHAR *fontName;
903
904 GdipNewPrivateFontCollection (&collection);
905 fontName = createWchar ("test.ttf");
906 GdipPrivateAddFontFile (collection, fontName);
907
908 status = GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
909 assertEqualInt (status, Ok);
910 verifyFontFamily (family, "Tahoma", 2049, 423, 2472, "DejaVu Sans", 1901, 483, 2384);
911
912 status = GdipCreateFontFamilyFromName (CodeNewRoman, collection, &family);
913 assertEqualInt (status, Ok);
914 verifyFontFamily (family, "Code New Roman", 1884, 514, 2398, "Code New Roman", 1884, 514, 2398);
915
916 // Negative tests.
917 status = GdipCreateFontFamilyFromName (NULL, collection, &family);
918 assertEqualInt (status, InvalidParameter);
919
920 status = GdipCreateFontFamilyFromName (CodeNewRoman, collection, NULL);
921 assertEqualInt (status, InvalidParameter);
922
923 // FIXME: Libgdiplus does not validate that the font family exists
924 // if the collection is NULL.
925 #if defined(USE_WINDOWS_GDIPLUS)
926 status = GdipCreateFontFamilyFromName (NoSuchFont, NULL, &family);
927 assertEqualInt (status, FontFamilyNotFound);
928 #endif
929
930 status = GdipCreateFontFamilyFromName (Tahoma, collection, &family);
931 assertEqualInt (status, FontFamilyNotFound);
932
933 status = GdipCreateFontFamilyFromName (NoSuchFont, collection, &family);
934 assertEqualInt (status, FontFamilyNotFound);
935
936 GdipDeletePrivateFontCollection (&collection);
937 freeWchar (fontName);
938 }
939
test_cloneFontFamily()940 static void test_cloneFontFamily ()
941 {
942 GpStatus status;
943 GpFontFamily *family;
944 GpFontFamily *clonedFamily;
945
946 GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
947
948 status = GdipCloneFontFamily (family, &clonedFamily);
949 assertEqualInt (status, Ok);
950 verifyFontFamily (clonedFamily, "Tahoma", 2049, 423, 2472, "DejaVu Sans", 1901, 483, 2384);
951
952 // Negative tests.
953 status = GdipCloneFontFamily (NULL, &clonedFamily);
954 assertEqualInt (status, InvalidParameter);
955
956 status = GdipCloneFontFamily (family, NULL);
957 assertEqualInt (status, InvalidParameter);
958
959 GdipDeleteFontFamily (family);
960 }
961
test_deleteFontFamily()962 static void test_deleteFontFamily ()
963 {
964 GpStatus status;
965 GpFontFamily *family;
966
967 GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
968
969 status = GdipDeleteFontFamily (family);
970 assertEqualInt (status, Ok);
971
972 // Negative tests.
973 status = GdipDeleteFontFamily (NULL);
974 assertEqualInt (status, InvalidParameter);
975 }
976
test_getGenericFontFamilySansSerif()977 static void test_getGenericFontFamilySansSerif ()
978 {
979 GpStatus status;
980 GpFontFamily *family1;
981 GpFontFamily *family2;
982
983 status = GdipGetGenericFontFamilySansSerif (&family1);
984 assertEqualInt (status, Ok);
985 assert (family1);
986
987 status = GdipGetGenericFontFamilySansSerif (&family2);
988 assertEqualInt (status, Ok);
989 assert (family2 && family1 == family2);
990
991 // Negative tests.
992 status = GdipGetGenericFontFamilySansSerif (NULL);
993 assertEqualInt (status, InvalidParameter);
994
995 GdipDeleteFontFamily (family1);
996 GdipDeleteFontFamily (family2);
997 }
998
test_getGenericFontFamilySerif()999 static void test_getGenericFontFamilySerif ()
1000 {
1001 GpStatus status;
1002 GpFontFamily *family1;
1003 GpFontFamily *family2;
1004
1005 status = GdipGetGenericFontFamilySerif (&family1);
1006 assertEqualInt (status, Ok);
1007 assert (family1);
1008
1009 status = GdipGetGenericFontFamilySerif (&family2);
1010 assertEqualInt (status, Ok);
1011 assert (family2 && family1 == family2);
1012
1013 // Negative tests.
1014 status = GdipGetGenericFontFamilySerif (NULL);
1015 assertEqualInt (status, InvalidParameter);
1016
1017 GdipDeleteFontFamily (family1);
1018 GdipDeleteFontFamily (family2);
1019 }
1020
test_getGenericFontFamilyMonospace()1021 static void test_getGenericFontFamilyMonospace ()
1022 {
1023 GpStatus status;
1024 GpFontFamily *family1;
1025 GpFontFamily *family2;
1026
1027 status = GdipGetGenericFontFamilyMonospace (&family1);
1028 assertEqualInt (status, Ok);
1029 assert (family1);
1030
1031 status = GdipGetGenericFontFamilyMonospace (&family2);
1032 assertEqualInt (status, Ok);
1033 assert (family2 && family1 == family2);
1034
1035 // Negative tests.
1036 status = GdipGetGenericFontFamilyMonospace (NULL);
1037 assertEqualInt (status, InvalidParameter);
1038
1039 GdipDeleteFontFamily (family1);
1040 GdipDeleteFontFamily (family2);
1041 }
1042
test_getFamilyName()1043 static void test_getFamilyName ()
1044 {
1045 GpStatus status;
1046 GpFontFamily *family;
1047 WCHAR name[LF_FACESIZE];
1048
1049 GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
1050
1051 status = GdipGetFamilyName (family, name, 57920);
1052 assertEqualInt (status, Ok);
1053 assert (stringsEqual(name, "Tahoma") || stringsEqual (name, "DejaVu Sans"));
1054
1055 // Negative tests.
1056 status = GdipGetFamilyName (NULL, name, 1);
1057 assertEqualInt (status, InvalidParameter);
1058
1059 status = GdipGetFamilyName (family, NULL, 1);
1060 assertEqualInt (status, Ok);
1061
1062 status = GdipGetFamilyName (NULL, NULL, 1);
1063 assertEqualInt (status, InvalidParameter);
1064
1065 GdipDeleteFontFamily (family);
1066 }
1067
test_isStyleAvailable()1068 static void test_isStyleAvailable ()
1069 {
1070 GpStatus status;
1071 GpFontFamily *family;
1072 BOOL isStyleAvailable;
1073
1074 GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
1075
1076 status = GdipIsStyleAvailable (family, FontStyleBold, &isStyleAvailable);
1077 assertEqualInt (status, Ok);
1078 assert (isStyleAvailable);
1079
1080 status = GdipIsStyleAvailable (family, -1, &isStyleAvailable);
1081 assertEqualInt (status, Ok);
1082 assert (isStyleAvailable);
1083
1084 status = GdipIsStyleAvailable (family, FontStyleStrikeout + 1, &isStyleAvailable);
1085 assertEqualInt (status, Ok);
1086 assert (isStyleAvailable);
1087
1088 // Negative tests.
1089 status = GdipIsStyleAvailable (NULL, FontStyleBold, &isStyleAvailable);
1090 assertEqualInt (status, InvalidParameter);
1091
1092 status = GdipIsStyleAvailable (family, FontStyleBold, NULL);
1093 assertEqualInt (status, InvalidParameter);
1094
1095 GdipDeleteFontFamily (family);
1096 }
1097
test_getEmHeight()1098 static void test_getEmHeight ()
1099 {
1100 GpStatus status;
1101 GpFontFamily *family;
1102 UINT16 emHeight;
1103
1104 GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
1105
1106 // Negative tests.
1107 status = GdipGetEmHeight (NULL, FontStyleBold, &emHeight);
1108 assertEqualInt (status, InvalidParameter);
1109
1110 status = GdipGetEmHeight (family, FontStyleBold, NULL);
1111 assertEqualInt (status, InvalidParameter);
1112
1113 GdipDeleteFontFamily (family);
1114 }
1115
test_getCellAscent()1116 static void test_getCellAscent ()
1117 {
1118 GpStatus status;
1119 GpFontFamily *family;
1120 UINT16 cellAscent;
1121
1122 GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
1123
1124 // Negative tests.
1125 status = GdipGetCellAscent (NULL, FontStyleBold, &cellAscent);
1126 assertEqualInt (status, InvalidParameter);
1127
1128 status = GdipGetCellAscent (family, FontStyleBold, NULL);
1129 assertEqualInt (status, InvalidParameter);
1130
1131 GdipDeleteFontFamily (family);
1132 }
1133
test_getCellDescent()1134 static void test_getCellDescent ()
1135 {
1136 GpStatus status;
1137 GpFontFamily *family;
1138 UINT16 cellDescent;
1139
1140 GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
1141
1142 // Negative tests.
1143 status = GdipGetCellDescent (NULL, FontStyleBold, &cellDescent);
1144 assertEqualInt (status, InvalidParameter);
1145
1146 status = GdipGetCellDescent (family, FontStyleBold, NULL);
1147 assertEqualInt (status, InvalidParameter);
1148
1149 GdipDeleteFontFamily (family);
1150 }
1151
test_getLineSpacing()1152 static void test_getLineSpacing ()
1153 {
1154 GpStatus status;
1155 GpFontFamily *family;
1156 UINT16 lineSpacing;
1157
1158 GdipCreateFontFamilyFromName (Tahoma, NULL, &family);
1159
1160 // Negative tests.
1161 status = GdipGetLineSpacing (NULL, FontStyleBold, &lineSpacing);
1162 assertEqualInt (status, InvalidParameter);
1163
1164 status = GdipGetLineSpacing (family, FontStyleBold, NULL);
1165 assertEqualInt (status, InvalidParameter);
1166
1167 GdipDeleteFontFamily (family);
1168 }
1169
1170 int
main(int argc,char ** argv)1171 main(int argc, char**argv)
1172 {
1173 STARTUP;
1174
1175 test_newPrivateFontCollection ();
1176 test_deletePrivateFontCollection ();
1177 test_getFontCollectionFamilyCount ();
1178 test_getFontCollectionFamilyList ();
1179 test_privateAddMemoryFont ();
1180 test_privateAddFontFile ();
1181 test_newInstalledFontCollection ();
1182 test_createFontFromDC ();
1183 test_createFontFromLogfontA ();
1184 test_createFontFromLogfontW ();
1185 test_createFont ();
1186 test_cloneFont ();
1187 test_deleteFont ();
1188 test_getFamily ();
1189 test_getFontStyle ();
1190 test_getFontSize ();
1191 test_getFontUnit ();
1192 test_getFontHeight ();
1193 test_getFontHeightGivenDPI ();
1194 test_getLogfontA ();
1195 test_getLogfontW ();
1196 test_createFontFamilyFromName ();
1197 test_cloneFontFamily ();
1198 test_deleteFontFamily ();
1199 test_getGenericFontFamilySansSerif ();
1200 test_getGenericFontFamilySerif ();
1201 test_getGenericFontFamilyMonospace ();
1202 test_getFamilyName ();
1203 test_isStyleAvailable ();
1204 test_getEmHeight ();
1205 test_getCellAscent ();
1206 test_getCellDescent ();
1207 test_getLineSpacing ();
1208
1209 SHUTDOWN;
1210 return 0;
1211 }
1212