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.lib")
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 "testhelpers.h"
25
verifyStringFormat(GpStringFormat * format,INT expectedAttributes,StringTrimming expectedTrimming)26 static void verifyStringFormat (GpStringFormat *format, INT expectedAttributes, StringTrimming expectedTrimming)
27 {
28 GpStatus status;
29 INT flags;
30 StringAlignment align;
31 LANGID language;
32 StringDigitSubstitute digitSubstitution;
33 StringAlignment lineAlign;
34 INT hotkeyPrefix;
35 StringTrimming trimming;
36 INT tabStopCount;
37 REAL firstTabOffset;
38 REAL tabStops[1];
39 INT measurableCharacterRangeCount;
40
41 status = GdipGetStringFormatFlags (format, &flags);
42 assertEqualInt (status, Ok);
43 assertEqualInt (flags, expectedAttributes);
44
45 status = GdipGetStringFormatAlign (format, &align);
46 assertEqualInt (status,Ok);
47 assertEqualInt (align, StringAlignmentNear);
48
49 status = GdipGetStringFormatDigitSubstitution (format, &language, &digitSubstitution);
50 assertEqualInt (status, Ok);
51 assertEqualInt (language, 0);
52 assertEqualInt (align, StringDigitSubstituteUser);
53
54 status = GdipGetStringFormatLineAlign (format, &lineAlign);
55 assertEqualInt (status, Ok);
56 assertEqualInt (lineAlign, StringAlignmentNear);
57
58 status = GdipGetStringFormatHotkeyPrefix (format, &hotkeyPrefix);
59 assertEqualInt (status, Ok);
60 assertEqualInt (hotkeyPrefix, HotkeyPrefixNone);
61
62 status = GdipGetStringFormatTrimming (format, &trimming);
63 assertEqualInt (status, Ok);
64 assertEqualInt (trimming, expectedTrimming);
65
66 status = GdipGetStringFormatTabStopCount (format, &tabStopCount);
67 assertEqualInt (status, Ok);
68 assertEqualInt (tabStopCount, 0);
69
70 status = GdipGetStringFormatTabStops (format, 0, &firstTabOffset, tabStops);
71 assertEqualInt (status, Ok);
72 assertEqualFloat (firstTabOffset, 0);
73
74 status = GdipGetStringFormatMeasurableCharacterRangeCount (format, &measurableCharacterRangeCount);
75 assertEqualInt (status, Ok);
76 assertEqualInt (measurableCharacterRangeCount, 0);
77 }
78
test_createStringFormat()79 static void test_createStringFormat ()
80 {
81 GpStatus status;
82 GpStringFormat *format;
83
84 // Positive values.
85 status = GdipCreateStringFormat (10, 11, &format);
86 assertEqualInt (status, Ok);
87 verifyStringFormat (format, 10, StringTrimmingCharacter);
88 GdipDeleteStringFormat (format);
89
90 // Zero values.
91 status = GdipCreateStringFormat (0, 0, &format);
92 assertEqualInt (status, Ok);
93 verifyStringFormat (format, 0, StringTrimmingCharacter);
94 GdipDeleteStringFormat (format);
95
96 // Negative values.
97 status = GdipCreateStringFormat (-1, -2, &format);
98 assertEqualInt (status, Ok);
99 verifyStringFormat (format, -1, StringTrimmingCharacter);
100 GdipDeleteStringFormat (format);
101
102 // Negative tests.
103 status = GdipCreateStringFormat (10, 11, NULL);
104 assertEqualInt (status, InvalidParameter);
105 }
106
test_getGenericDefault()107 static void test_getGenericDefault ()
108 {
109 GpStatus status;
110 GpStringFormat *format1;
111 GpStringFormat *format2;
112 StringAlignment lineAlign;
113
114 // Should be a singleton.
115 status = GdipStringFormatGetGenericDefault (&format1);
116 assertEqualInt (status, Ok);
117 assert (format1);
118 verifyStringFormat (format1, 0, StringTrimmingCharacter);
119
120 status = GdipStringFormatGetGenericDefault (&format2);
121 assertEqualInt (status, Ok);
122 assert (format2);
123 verifyStringFormat (format2, 0, StringTrimmingCharacter);
124 assert (format1 == format2);
125
126 // Should not be deleted.
127 status = GdipDeleteStringFormat (format2);
128 assertEqualInt (status, Ok);
129
130 status = GdipStringFormatGetGenericDefault (&format2);
131 assertEqualInt (status, Ok);
132 verifyStringFormat (format2, 0, StringTrimmingCharacter);
133 assert (format1 == format2);
134
135 // Should be mutable.
136 status = GdipSetStringFormatLineAlign (format1, StringAlignmentFar);
137 assertEqualInt (status, Ok);
138
139 status = GdipSetStringFormatLineAlign (format1, StringAlignmentFar);
140 assertEqualInt (status, Ok);
141
142 status = GdipGetStringFormatLineAlign (format1, &lineAlign);
143 assertEqualInt (status, Ok);
144 assertEqualInt (lineAlign, StringAlignmentFar);
145
146 // Set back to the default.
147 status = GdipSetStringFormatLineAlign (format1, StringAlignmentNear);
148 assertEqualInt (status, Ok);
149
150 // Negative tests.
151 status = GdipStringFormatGetGenericDefault (NULL);
152 assertEqualInt (status, InvalidParameter);
153 }
154
test_getGenericTypographic()155 static void test_getGenericTypographic ()
156 {
157 GpStatus status;
158 GpStringFormat *format1;
159 GpStringFormat *format2;
160 StringAlignment lineAlign;
161
162 // Should be a singleton.
163 status = GdipStringFormatGetGenericTypographic (&format1);
164 assertEqualInt (status, Ok);
165 verifyStringFormat (format1, StringFormatFlagsNoFitBlackBox | StringFormatFlagsLineLimit | StringFormatFlagsNoClip, StringTrimmingNone);
166
167 status = GdipStringFormatGetGenericTypographic (&format2);
168 assertEqualInt (status, Ok);
169 verifyStringFormat (format2, StringFormatFlagsNoFitBlackBox | StringFormatFlagsLineLimit | StringFormatFlagsNoClip, StringTrimmingNone);
170 assert (format1 == format2);
171
172 // Should not be deleted.
173 status = GdipDeleteStringFormat (format2);
174 assertEqualInt (status, Ok);
175
176 status = GdipStringFormatGetGenericTypographic (&format2);
177 assertEqualInt (status, Ok);
178 verifyStringFormat (format2, StringFormatFlagsNoFitBlackBox | StringFormatFlagsLineLimit | StringFormatFlagsNoClip, StringTrimmingNone);
179 assert (format1 == format2);
180
181 // Should be mutable.
182 status = GdipSetStringFormatLineAlign (format1, StringAlignmentFar);
183 assertEqualInt (status, Ok);
184
185 status = GdipGetStringFormatLineAlign (format1, &lineAlign);
186 assertEqualInt (status, Ok);
187 assertEqualInt (lineAlign, StringAlignmentFar);
188
189 // Set back to the default.
190 status = GdipSetStringFormatLineAlign (format1, StringAlignmentNear);
191 assertEqualInt (status, Ok);
192
193 // Negative tests.
194 status = GdipStringFormatGetGenericTypographic (NULL);
195 assertEqualInt (status, InvalidParameter);
196 }
197
test_deleteStringFormat()198 static void test_deleteStringFormat ()
199 {
200 GpStatus status;
201 GpStringFormat *format;
202
203 GdipCreateStringFormat (10, 11, &format);
204
205 status = GdipDeleteStringFormat (format);
206 assertEqualInt (status, Ok);
207
208 // Negative tests.
209 status = GdipDeleteStringFormat (NULL);
210 assertEqualInt (status, InvalidParameter);
211 }
212
test_cloneStringFormat()213 static void test_cloneStringFormat ()
214 {
215 GpStatus status;
216 GpStringFormat *format;
217 GpStringFormat *clonedFormat;
218
219 GdipCreateStringFormat (10, 11, &format);
220
221 status = GdipCloneStringFormat (format, &clonedFormat);
222 assertEqualInt (status, Ok);
223 verifyStringFormat (clonedFormat, 10, StringTrimmingCharacter);
224 GdipDeleteStringFormat (clonedFormat);
225
226 // Negative tests.
227 status = GdipCloneStringFormat (NULL, &clonedFormat);
228 assertEqualInt (status, InvalidParameter);
229
230 status = GdipCloneStringFormat (format, NULL);
231 assertEqualInt (status, InvalidParameter);
232
233 GdipDeleteStringFormat (format);
234 }
235
test_setStringFormatAlign()236 static void test_setStringFormatAlign ()
237 {
238 GpStatus status;
239 GpStringFormat *format;
240 StringAlignment align;
241
242 GdipCreateStringFormat (10, 11, &format);
243
244 // StringAlignmentCenter.
245 status = GdipSetStringFormatAlign (format, StringAlignmentNear);
246 assertEqualInt (status, Ok);
247
248 GdipGetStringFormatAlign (format, &align);
249 assertEqualInt (align, StringAlignmentNear);
250
251 // Same.
252 status = GdipSetStringFormatAlign (format, StringAlignmentNear);
253 assertEqualInt (status, Ok);
254
255 GdipGetStringFormatAlign (format, &align);
256 assertEqualInt (align, StringAlignmentNear);
257
258 // StringAlignmentCenter.
259 status = GdipSetStringFormatAlign (format, StringAlignmentCenter);
260 assertEqualInt (status, Ok);
261
262 GdipGetStringFormatAlign (format, &align);
263 assertEqualInt (align, StringAlignmentCenter);
264
265 // StringAlignmentFar.
266 status = GdipSetStringFormatAlign (format, StringAlignmentFar);
267 assertEqualInt (status, Ok);
268
269 GdipGetStringFormatAlign (format, &align);
270 assertEqualInt (align, StringAlignmentFar);
271
272 // Negative tests.
273 status = GdipSetStringFormatAlign (NULL, StringAlignmentCenter);
274 assertEqualInt (status, InvalidParameter);
275
276 status = GdipSetStringFormatAlign (format, (StringAlignment)(StringAlignmentNear - 1));
277 assertEqualInt (status, InvalidParameter);
278
279 status = GdipSetStringFormatAlign (format, (StringAlignment)(StringAlignmentFar + 1));
280 assertEqualInt (status, InvalidParameter);
281
282 GdipDeleteStringFormat (format);
283 }
284
test_getStringFormatAlign()285 static void test_getStringFormatAlign ()
286 {
287 GpStatus status;
288 GpStringFormat *format;
289 StringAlignment align;
290
291 GdipCreateStringFormat (10, 11, &format);
292
293 // Negative tests.
294 status = GdipGetStringFormatAlign (NULL, &align);
295 assertEqualInt (status, InvalidParameter);
296
297 status = GdipGetStringFormatAlign (format, NULL);
298 assertEqualInt (status, InvalidParameter);
299
300 GdipDeleteStringFormat (format);
301 }
302
test_setStringFormatLineAlign()303 static void test_setStringFormatLineAlign ()
304 {
305 GpStatus status;
306 GpStringFormat *format;
307 StringAlignment lineAlign;
308
309 GdipCreateStringFormat (10, 11, &format);
310
311 // StringAlignmentNear.
312 status = GdipSetStringFormatLineAlign (format, StringAlignmentNear);
313 assertEqualInt (status, Ok);
314
315 GdipGetStringFormatLineAlign (format, &lineAlign);
316 assertEqualInt (lineAlign, StringAlignmentNear);
317
318 // Same.
319 status = GdipSetStringFormatLineAlign (format, StringAlignmentNear);
320 assertEqualInt (status, Ok);
321
322 GdipGetStringFormatLineAlign (format, &lineAlign);
323 assertEqualInt (lineAlign, StringAlignmentNear);
324
325 // StringAlignmentCenter.
326 status = GdipSetStringFormatLineAlign (format, StringAlignmentCenter);
327 assertEqualInt (status, Ok);
328
329 GdipGetStringFormatLineAlign (format, &lineAlign);
330 assertEqualInt (lineAlign, StringAlignmentCenter);
331
332 // StringAlignmentFar.
333 status = GdipSetStringFormatLineAlign (format, StringAlignmentFar);
334 assertEqualInt (status, Ok);
335
336 GdipGetStringFormatLineAlign (format, &lineAlign);
337 assertEqualInt (lineAlign, StringAlignmentFar);
338
339 // Negative tests.
340 status = GdipSetStringFormatLineAlign (NULL, StringAlignmentCenter);
341 assertEqualInt (status, InvalidParameter);
342
343 status = GdipSetStringFormatLineAlign (format, (StringAlignment)(StringAlignmentNear - 1));
344 assertEqualInt (status, InvalidParameter);
345
346 status = GdipSetStringFormatLineAlign (format, (StringAlignment)(StringAlignmentFar + 1));
347 assertEqualInt (status, InvalidParameter);
348
349 GdipDeleteStringFormat (format);
350 }
351
test_getStringFormatLineAlign()352 static void test_getStringFormatLineAlign ()
353 {
354 GpStatus status;
355 GpStringFormat *format;
356 StringAlignment lineAlign;
357
358 GdipCreateStringFormat (10, 11, &format);
359
360 // Negative tests.
361 status = GdipGetStringFormatLineAlign (NULL, &lineAlign);
362 assertEqualInt (status, InvalidParameter);
363
364 status = GdipGetStringFormatLineAlign (format, NULL);
365 assertEqualInt (status, InvalidParameter);
366
367 GdipDeleteStringFormat (format);
368 }
369
test_setStringFormatTrimming()370 static void test_setStringFormatTrimming ()
371 {
372 GpStatus status;
373 GpStringFormat *format;
374 StringTrimming trimming;
375
376 GdipCreateStringFormat (10, 11, &format);
377
378 // StringTrimmingNone
379 status = GdipSetStringFormatTrimming (format, StringTrimmingNone);
380 assertEqualInt (status, Ok);
381
382 GdipGetStringFormatTrimming (format, &trimming);
383 assertEqualInt (trimming, StringTrimmingNone);
384
385 // Same.
386 status = GdipSetStringFormatTrimming (format, StringTrimmingNone);
387 assertEqualInt (status, Ok);
388
389 GdipGetStringFormatTrimming (format, &trimming);
390 assertEqualInt (trimming, StringTrimmingNone);
391
392 // StringTrimmingEllipsisCharacter.
393 status = GdipSetStringFormatTrimming (format, StringTrimmingCharacter);
394 assertEqualInt (status, Ok);
395
396 GdipGetStringFormatTrimming (format, &trimming);
397 assertEqualInt (trimming, StringTrimmingCharacter);
398
399 // StringTrimmingWord.
400 status = GdipSetStringFormatTrimming (format, StringTrimmingWord);
401 assertEqualInt (status, Ok);
402
403 GdipGetStringFormatTrimming (format, &trimming);
404 assertEqualInt (trimming, StringTrimmingWord);
405
406 // StringTrimmingEllipsisCharacter.
407 status = GdipSetStringFormatTrimming (format, StringTrimmingEllipsisCharacter);
408 assertEqualInt (status, Ok);
409
410 GdipGetStringFormatTrimming (format, &trimming);
411 assertEqualInt (trimming, StringTrimmingEllipsisCharacter);
412
413 // StringTrimmingEllipsisWord.
414 status = GdipSetStringFormatTrimming (format, StringTrimmingEllipsisWord);
415 assertEqualInt (status, Ok);
416
417 GdipGetStringFormatTrimming (format, &trimming);
418 assertEqualInt (trimming, StringTrimmingEllipsisWord);
419
420 // StringTrimmingEllipsisPath.
421 status = GdipSetStringFormatTrimming (format, StringTrimmingEllipsisPath);
422 assertEqualInt (status, Ok);
423
424 GdipGetStringFormatTrimming (format, &trimming);
425 assertEqualInt (trimming, StringTrimmingEllipsisPath);
426
427 // Negative tests.
428 status = GdipSetStringFormatTrimming (NULL, StringTrimmingEllipsisCharacter);
429 assertEqualInt (status, InvalidParameter);
430
431 status = GdipSetStringFormatTrimming (format, (StringTrimming)(StringTrimmingNone - 1));
432 assertEqualInt (status, InvalidParameter);
433
434 status = GdipSetStringFormatTrimming (format, (StringTrimming)(StringTrimmingEllipsisPath + 1));
435 assertEqualInt (status, InvalidParameter);
436
437 GdipDeleteStringFormat (format);
438 }
439
test_getStringFormatTrimming()440 static void test_getStringFormatTrimming ()
441 {
442 GpStatus status;
443 GpStringFormat *format;
444 StringTrimming trimming;
445
446 GdipCreateStringFormat (10, 11, &format);
447
448 // Negative tests.
449 status = GdipGetStringFormatTrimming (NULL, &trimming);
450 assertEqualInt (status, InvalidParameter);
451
452 status = GdipGetStringFormatTrimming (format, NULL);
453 assertEqualInt (status, InvalidParameter);
454
455 GdipDeleteStringFormat (format);
456 }
457
test_setStringFormatHotkeyPrefix()458 static void test_setStringFormatHotkeyPrefix ()
459 {
460 GpStatus status;
461 GpStringFormat *format;
462 INT hotkeyPrefix;
463
464 GdipCreateStringFormat (10, 11, &format);
465
466 // HotkeyPrefixNone.
467 status = GdipSetStringFormatHotkeyPrefix (format, HotkeyPrefixNone);
468 assertEqualInt (status, Ok);
469
470 GdipGetStringFormatHotkeyPrefix (format, &hotkeyPrefix);
471 assertEqualInt (hotkeyPrefix, HotkeyPrefixNone);
472
473 // Same.
474 status = GdipSetStringFormatHotkeyPrefix (format, HotkeyPrefixNone);
475 assertEqualInt (status, Ok);
476
477 GdipGetStringFormatHotkeyPrefix (format, &hotkeyPrefix);
478 assertEqualInt (hotkeyPrefix, HotkeyPrefixNone);
479
480 // HotkeyPrefixShow.
481 status = GdipSetStringFormatHotkeyPrefix (format, HotkeyPrefixShow);
482 assertEqualInt (status, Ok);
483
484 GdipGetStringFormatHotkeyPrefix (format, &hotkeyPrefix);
485 assertEqualInt (hotkeyPrefix, HotkeyPrefixShow);
486
487 // HotkeyPrefixHide.
488 status = GdipSetStringFormatHotkeyPrefix (format, HotkeyPrefixHide);
489 assertEqualInt (status, Ok);
490
491 GdipGetStringFormatHotkeyPrefix (format, &hotkeyPrefix);
492 assertEqualInt (hotkeyPrefix, HotkeyPrefixHide);
493
494 // Negative tests.
495 status = GdipSetStringFormatHotkeyPrefix (NULL, HotkeyPrefixNone);
496 assertEqualInt (status, InvalidParameter);
497
498 status = GdipSetStringFormatHotkeyPrefix (format, (HotkeyPrefix)(HotkeyPrefixNone - 1));
499 assertEqualInt (status, InvalidParameter);
500
501 status = GdipSetStringFormatHotkeyPrefix (format, (HotkeyPrefix)(HotkeyPrefixHide + 1));
502 assertEqualInt (status, InvalidParameter);
503
504 GdipDeleteStringFormat (format);
505 }
506
test_getStringFormatHotkeyPrefix()507 static void test_getStringFormatHotkeyPrefix ()
508 {
509 GpStatus status;
510 GpStringFormat *format;
511 INT hotkeyPrefix;
512
513 GdipCreateStringFormat (10, 11, &format);
514
515 // Negative tests.
516 status = GdipGetStringFormatHotkeyPrefix (NULL, &hotkeyPrefix);
517 assertEqualInt (status, InvalidParameter);
518
519 status = GdipGetStringFormatHotkeyPrefix (format, NULL);
520 assertEqualInt (status, InvalidParameter);
521
522 GdipDeleteStringFormat (format);
523 }
524
test_setStringFormatTabStops()525 static void test_setStringFormatTabStops ()
526 {
527 GpStatus status;
528 GpStringFormat *format;
529 REAL firstTabOffset;
530 REAL tabStops1[4] = {1, 0, 2, 3};
531 REAL tabStops2[4] = {3, 2, 0, 1};
532 REAL oneTabStop[1] = {0};
533 REAL negativeValueInTabStops[4] = {1, -1};
534 REAL formatTabStops[4];
535
536 GdipCreateStringFormat (10, 11, &format);
537
538 // Count of 4.
539 status = GdipSetStringFormatTabStops (format, 10, 4, tabStops1);
540 assertEqualInt (status, Ok);
541
542 GdipGetStringFormatTabStops (format, 4, &firstTabOffset, formatTabStops);
543 assertEqualFloat (firstTabOffset, 10);
544 assertEqualFloat (formatTabStops[0], 1);
545 assertEqualFloat (formatTabStops[1], 0);
546 assertEqualFloat (formatTabStops[2], 2);
547 assertEqualFloat (formatTabStops[3], 3);
548
549 // Count of 4 again.
550 status = GdipSetStringFormatTabStops (format, FLT_MAX, 4, tabStops2);
551 assertEqualInt (status, Ok);
552
553 GdipGetStringFormatTabStops (format, 4, &firstTabOffset, formatTabStops);
554 assertEqualFloat (firstTabOffset, FLT_MAX);
555 assertEqualFloat (formatTabStops[0], 3);
556 assertEqualFloat (formatTabStops[1], 2);
557 assertEqualFloat (formatTabStops[2], 0);
558 assertEqualFloat (formatTabStops[3], 1);
559
560 // Count of 1.
561 status = GdipSetStringFormatTabStops (format, 0, 1, oneTabStop);
562 assertEqualInt (status, Ok);
563
564 GdipGetStringFormatTabStops (format, 1, &firstTabOffset, formatTabStops);
565 assertEqualFloat (firstTabOffset, 0);
566 assertEqualFloat (formatTabStops[0], 0);
567
568 // Count of 0.
569 status = GdipSetStringFormatTabStops (format, 10, 0, oneTabStop);
570 assertEqualInt (status, Ok);
571
572 GdipGetStringFormatTabStops (format, 1, &firstTabOffset, formatTabStops);
573 assertEqualFloat (firstTabOffset, 0);
574 assertEqualFloat (formatTabStops[0], 0);
575
576 // Count of -1.
577 status = GdipSetStringFormatTabStops (format, 10, -1, oneTabStop);
578 assertEqualInt (status, Ok);
579
580 GdipGetStringFormatTabStops (format, 1, &firstTabOffset, formatTabStops);
581 assertEqualFloat (firstTabOffset, 0);
582 assertEqualFloat (formatTabStops[0], 0);
583
584 // Count of 0, invalid first tab offset.
585 status = GdipSetStringFormatTabStops (format, -1, 0, oneTabStop);
586 assertEqualInt (status, Ok);
587
588 GdipGetStringFormatTabStops (format, 1, &firstTabOffset, formatTabStops);
589 assertEqualFloat (firstTabOffset, 0);
590 assertEqualFloat (formatTabStops[0], 0);
591
592 // Negative tests,
593 status = GdipSetStringFormatTabStops (NULL, 10, -1, oneTabStop);
594 assertEqualInt (status, InvalidParameter);
595
596 status = GdipSetStringFormatTabStops (format, 10, -1, NULL);
597 assertEqualInt (status, InvalidParameter);
598
599 status = GdipSetStringFormatTabStops (format, -1, 10, oneTabStop);
600 assertEqualInt (status, NotImplemented);
601
602 // Negative value in tab stops.
603 formatTabStops[0] = 10;
604 status = GdipSetStringFormatTabStops (format, 40, 4, negativeValueInTabStops);
605 assertEqualInt (status, NotImplemented);
606
607 status = GdipGetStringFormatTabStops (format, 4, &firstTabOffset, formatTabStops);
608 assertEqualInt (status, Ok);
609 assertEqualFloat (firstTabOffset, 0);
610 assertEqualFloat (formatTabStops[0], 0);
611
612 GdipDeleteStringFormat (format);
613 }
614
test_getStringFormatTabStops()615 static void test_getStringFormatTabStops ()
616 {
617 GpStatus status;
618 GpStringFormat *format;
619 REAL firstTabOffset = 10;
620 REAL tabStops[4] = {1, 2, 3, 4};
621 REAL formatTabStops[5] = {-1, -2, -3, -4, -5};
622
623 GdipCreateStringFormat (10, 11, &format);
624
625 // Count of 0 - still overwrites the firstTabOffset value.
626 status = GdipGetStringFormatTabStops (format, 0, &firstTabOffset, formatTabStops);
627 assertEqualInt (status, Ok);
628 assertEqualFloat (firstTabOffset, 0);
629
630 // Count less than the number of tab stops.
631 GdipSetStringFormatTabStops (format, 10, 4, tabStops);
632
633 status = GdipGetStringFormatTabStops (format, 2, &firstTabOffset, formatTabStops);
634 assertEqualInt (status, Ok);
635 assertEqualFloat (firstTabOffset, 10);
636 assertEqualFloat (formatTabStops[0], 1);
637 assertEqualFloat (formatTabStops[1], 2);
638 assertEqualFloat (formatTabStops[2], -3);
639 assertEqualFloat (formatTabStops[3], -4);
640 assertEqualFloat (formatTabStops[4], -5);
641
642 // Count greater than the number of tab stops.
643 GdipSetStringFormatTabStops (format, 10, 4, tabStops);
644
645 status = GdipGetStringFormatTabStops (format, 5, &firstTabOffset, formatTabStops);
646 assertEqualInt (status, Ok);
647 assertEqualFloat (firstTabOffset, 10);
648 assertEqualFloat (formatTabStops[0], 1);
649 assertEqualFloat (formatTabStops[1], 2);
650 assertEqualFloat (formatTabStops[2], 3);
651 assertEqualFloat (formatTabStops[3], 4);
652 assertEqualFloat (formatTabStops[4], -5);
653
654 // Negative tests,
655 status = GdipGetStringFormatTabStops (NULL, 0, &firstTabOffset, formatTabStops);
656 assertEqualInt (status, InvalidParameter);
657
658 status = GdipGetStringFormatTabStops (NULL, -1, &firstTabOffset, formatTabStops);
659 assertEqualInt (status, InvalidParameter);
660
661 status = GdipGetStringFormatTabStops (format, 0, NULL, formatTabStops);
662 assertEqualInt (status, InvalidParameter);
663
664 status = GdipGetStringFormatTabStops (format, -1, NULL, formatTabStops);
665 assertEqualInt (status, InvalidParameter);
666
667 status = GdipGetStringFormatTabStops (format, 0, &firstTabOffset, NULL);
668 assertEqualInt (status, InvalidParameter);
669
670 status = GdipGetStringFormatTabStops (format, -1, &firstTabOffset, NULL);
671 assertEqualInt (status, InvalidParameter);
672
673 // This causes GDI+ to crash.
674 #if !defined(USE_WINDOWS_GDIPLUS)
675 status = GdipGetStringFormatTabStops (format, -1, &firstTabOffset, formatTabStops);
676 assertEqualInt (status, InvalidParameter);
677 #endif
678
679 GdipDeleteStringFormat (format);
680 }
681
test_getStringFormatTabStopCount()682 static void test_getStringFormatTabStopCount ()
683 {
684 GpStatus status;
685 GpStringFormat *format;
686 INT tabStopCount;
687
688 GdipCreateStringFormat (10, 11, &format);
689
690 // Negative tests.
691 status = GdipGetStringFormatTabStopCount (NULL, &tabStopCount);
692 assertEqualInt (status, InvalidParameter);
693
694 status = GdipGetStringFormatTabStopCount (format, NULL);
695 assertEqualInt (status, InvalidParameter);
696
697 GdipDeleteStringFormat (format);
698 }
699
test_setStringFormatDigitSubstitution()700 static void test_setStringFormatDigitSubstitution ()
701 {
702 GpStatus status;
703 GpStringFormat *format;
704 LANGID language;
705 StringDigitSubstitute substitute;
706
707 GdipCreateStringFormat (10, 11, &format);
708
709 // StringDigitSubstituteUser.
710 status = GdipSetStringFormatDigitSubstitution (format, 10, StringDigitSubstituteUser);
711 assertEqualInt (status, Ok);
712
713 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
714 assertEqualInt (language, 10);
715 assertEqualInt (substitute, StringDigitSubstituteUser);
716
717 // Same.
718 status = GdipSetStringFormatDigitSubstitution (format, 10, StringDigitSubstituteUser);
719 assertEqualInt (status, Ok);
720
721 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
722 assertEqualInt (language, 10);
723 assertEqualInt (substitute, StringDigitSubstituteUser);
724
725 // Different language, same substitute.
726 status = GdipSetStringFormatDigitSubstitution (format, 12, StringDigitSubstituteUser);
727 assertEqualInt (status, Ok);
728
729 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
730 assertEqualInt (language, 12);
731 assertEqualInt (substitute, StringDigitSubstituteUser);
732
733 // Same language, different substitute.
734 status = GdipSetStringFormatDigitSubstitution (format, 12, StringDigitSubstituteNone);
735 assertEqualInt (status, Ok);
736
737 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
738 assertEqualInt (language, 12);
739 assertEqualInt (substitute, StringDigitSubstituteNone);
740
741 // StringDigitSubstituteNone.
742 status = GdipSetStringFormatDigitSubstitution (format, 10, StringDigitSubstituteNone);
743 assertEqualInt (status, Ok);
744
745 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
746 assertEqualInt (language, 10);
747 assertEqualInt (substitute, StringDigitSubstituteNone);
748
749 // StringDigitSubstituteNational.
750 status = GdipSetStringFormatDigitSubstitution (format, 10, StringDigitSubstituteNational);
751 assertEqualInt (status, Ok);
752
753 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
754 assertEqualInt (language, 10);
755 assertEqualInt (substitute, StringDigitSubstituteNational);
756
757 // StringDigitSubstituteTraditional.
758 status = GdipSetStringFormatDigitSubstitution (format, 10, StringDigitSubstituteTraditional);
759 assertEqualInt (status, Ok);
760
761 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
762 assertEqualInt (language, 10);
763 assertEqualInt (substitute, StringDigitSubstituteTraditional);
764
765 // Invalid value - negative.
766 status = GdipSetStringFormatDigitSubstitution (format, 0, (StringDigitSubstitute)(StringDigitSubstituteUser - 1));
767 assertEqualInt (status, Ok);
768
769 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
770 assertEqualInt (language, 0);
771 assertEqualInt (substitute, (StringDigitSubstitute)(StringDigitSubstituteUser - 1));
772
773 // Invalid value - positive.
774 status = GdipSetStringFormatDigitSubstitution (format, 0, (StringDigitSubstitute)(StringDigitSubstituteTraditional + 1));
775 assertEqualInt (status, Ok);
776
777 GdipGetStringFormatDigitSubstitution (format, &language, &substitute);
778 assertEqualInt (language, 0);
779 assertEqualInt (substitute, (StringDigitSubstitute)(StringDigitSubstituteTraditional + 1));
780
781 // Negative tests.
782 status = GdipSetStringFormatDigitSubstitution (NULL, 0, StringDigitSubstituteNational);
783 assertEqualInt (status, InvalidParameter);
784
785 GdipDeleteStringFormat (format);
786 }
787
test_getStringFormatDigitSubstitution()788 static void test_getStringFormatDigitSubstitution ()
789 {
790 GpStatus status;
791 GpStringFormat *format;
792 LANGID language;
793 StringDigitSubstitute substitute;
794
795 GdipCreateStringFormat (10, 11, &format);
796
797 // Language null.
798 status = GdipGetStringFormatDigitSubstitution (format, &language, NULL);
799 assertEqualInt (status, Ok);
800 assertEqualInt (language, 0);
801
802 // Substitution null.
803 status = GdipGetStringFormatDigitSubstitution (format, NULL, &substitute);
804 assertEqualInt (status, Ok);
805 assertEqualInt (substitute, StringDigitSubstituteUser);
806
807 // Both null.
808 status = GdipGetStringFormatDigitSubstitution (format, NULL, NULL);
809 assertEqualInt (status, Ok);
810
811 // Negative tests.
812 status = GdipGetStringFormatDigitSubstitution (NULL, &language, &substitute);
813 assertEqualInt (status, InvalidParameter);
814
815 GdipDeleteStringFormat (format);
816 }
817
test_setStringFormatFlags()818 static void test_setStringFormatFlags ()
819 {
820 GpStatus status;
821 GpStringFormat *format;
822 INT flags;
823
824 GdipCreateStringFormat (10, 11, &format);
825
826 // Custom flags.
827 status = GdipSetStringFormatFlags (format, 1234);
828 assertEqualInt (status, Ok);
829
830 GdipGetStringFormatFlags (format, &flags);
831 assertEqualInt (flags, 1234);
832
833 // Same.
834 status = GdipSetStringFormatFlags (format, 1234);
835 assertEqualInt (status, Ok);
836
837 GdipGetStringFormatFlags (format, &flags);
838 assertEqualInt (flags, 1234);
839
840 // Zero.
841 status = GdipSetStringFormatFlags (format, 0);
842 assertEqualInt (status, Ok);
843
844 GdipGetStringFormatFlags (format, &flags);
845 assertEqualInt (flags, 0);
846
847 // Negative.
848 status = GdipSetStringFormatFlags (format, -1234);
849 assertEqualInt (status, Ok);
850
851 GdipGetStringFormatFlags (format, &flags);
852 assertEqualInt (flags, -1234);
853
854 // Negative tests.
855 status = GdipSetStringFormatFlags (NULL, 1234);
856 assertEqualInt (status, InvalidParameter);
857
858 GdipDeleteStringFormat (format);
859 }
860
test_getStringFormatFlags()861 static void test_getStringFormatFlags ()
862 {
863 GpStatus status;
864 GpStringFormat *format;
865 INT flags;
866
867 GdipCreateStringFormat (10, 11, &format);
868
869 // Negative tests.
870 status = GdipGetStringFormatFlags (NULL, &flags);
871 assertEqualInt (status, InvalidParameter);
872
873 status = GdipGetStringFormatFlags (format, NULL);
874 assertEqualInt (status, InvalidParameter);
875
876 GdipDeleteStringFormat (format);
877 }
878
test_getStringFormatMeasurableCharacterRangeCount()879 static void test_getStringFormatMeasurableCharacterRangeCount ()
880 {
881 GpStatus status;
882 GpStringFormat *format;
883 INT measurableCharacterRangeCount;
884
885 GdipCreateStringFormat (10, 11, &format);
886
887 // Negative tests.
888 status = GdipGetStringFormatMeasurableCharacterRangeCount (NULL, &measurableCharacterRangeCount);
889 assertEqualInt (status, InvalidParameter);
890
891 status = GdipGetStringFormatMeasurableCharacterRangeCount (format, NULL);
892 assertEqualInt (status, InvalidParameter);
893
894 GdipDeleteStringFormat (format);
895 }
896
test_setStringFormatMeasurableCharacterRanges()897 static void test_setStringFormatMeasurableCharacterRanges ()
898 {
899 GpStatus status;
900 GpStringFormat *format;
901 CharacterRange ranges[32];
902 INT measurableCharacterRangeCount;
903
904 GdipCreateStringFormat (10, 11, &format);
905
906 // Count of 1.
907 status = GdipSetStringFormatMeasurableCharacterRanges (format, 1, ranges);
908 assertEqualInt (status, Ok);
909
910 GdipGetStringFormatMeasurableCharacterRangeCount (format, &measurableCharacterRangeCount);
911 assertEqualInt (measurableCharacterRangeCount, 1);
912
913 // Count of 1 again.
914 status = GdipSetStringFormatMeasurableCharacterRanges (format, 1, ranges);
915 assertEqualInt (status, Ok);
916
917 GdipGetStringFormatMeasurableCharacterRangeCount (format, &measurableCharacterRangeCount);
918 assertEqualInt (measurableCharacterRangeCount, 1);
919
920 // Count of 0.
921 GdipSetStringFormatMeasurableCharacterRanges (format, 3, ranges);
922
923 status = GdipSetStringFormatMeasurableCharacterRanges (format, 0, ranges);
924 assertEqualInt (status, Ok);
925
926 GdipGetStringFormatMeasurableCharacterRangeCount (format, &measurableCharacterRangeCount);
927 assertEqualInt (measurableCharacterRangeCount, 0);
928
929 // Count of -1.
930 GdipSetStringFormatMeasurableCharacterRanges (format, 3, ranges);
931
932 status = GdipSetStringFormatMeasurableCharacterRanges (format, -1, ranges);
933 assertEqualInt (status, Ok);
934
935 GdipGetStringFormatMeasurableCharacterRangeCount (format, &measurableCharacterRangeCount);
936 assertEqualInt (measurableCharacterRangeCount, 0);
937
938 // Count of 32.
939 status = GdipSetStringFormatMeasurableCharacterRanges (format, 32, ranges);
940 assertEqualInt (status, Ok);
941
942 GdipGetStringFormatMeasurableCharacterRangeCount (format, &measurableCharacterRangeCount);
943 assertEqualInt (measurableCharacterRangeCount, 32);
944
945 // Negative tests.
946 status = GdipSetStringFormatMeasurableCharacterRanges (NULL, 0, ranges);
947 assertEqualInt (status, InvalidParameter);
948
949 status = GdipSetStringFormatMeasurableCharacterRanges (format, 0, NULL);
950 assertEqualInt (status, InvalidParameter);
951
952 status = GdipSetStringFormatMeasurableCharacterRanges (format, 33, ranges);
953 assertEqualInt (status, ValueOverflow);
954
955 GdipDeleteStringFormat (format);
956 }
957
958 int
main(int argc,char ** argv)959 main (int argc, char**argv)
960 {
961 STARTUP;
962
963 test_createStringFormat ();
964 test_getGenericDefault ();
965 test_getGenericTypographic ();
966 test_deleteStringFormat ();
967 test_cloneStringFormat ();
968 test_setStringFormatAlign ();
969 test_getStringFormatAlign ();
970 test_setStringFormatLineAlign ();
971 test_getStringFormatLineAlign ();
972 test_setStringFormatTrimming ();
973 test_getStringFormatTrimming ();
974 test_setStringFormatHotkeyPrefix ();
975 test_getStringFormatHotkeyPrefix ();
976 test_setStringFormatTabStops ();
977 test_getStringFormatTabStops ();
978 test_getStringFormatTabStopCount ();
979 test_setStringFormatDigitSubstitution ();
980 test_getStringFormatDigitSubstitution ();
981 test_setStringFormatFlags ();
982 test_getStringFormatFlags ();
983 test_getStringFormatMeasurableCharacterRangeCount ();
984 test_setStringFormatMeasurableCharacterRanges ();
985
986 SHUTDOWN;
987 return 0;
988 }
989