4 * Copyright 2006 Jeff Latimer
5 * Copyright 2006 Hans Leidekker
6 * Copyright 2010 CodeWeavers, Aric Stewart
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 * Uniscribe allows for processing of complex scripts such as joining
24 * and filtering characters and bi-directional text with custom line breaks.
30 #include <wine/test.h>
34 typedef struct _itemTest
{
42 static inline void _test_items_ok(LPCWSTR string
, DWORD cchString
,
43 SCRIPT_CONTROL
*Control
, SCRIPT_STATE
*State
,
44 DWORD nItems
, const itemTest
* items
, BOOL nItemsToDo
,
49 SCRIPT_ITEM outpItems
[15];
51 hr
= ScriptItemize(string
, cchString
, 15, Control
, State
, outpItems
, &outnItems
);
52 winetest_ok(!hr
, "ScriptItemize should return S_OK not %08x\n", hr
);
53 if (nItemsBroken
&& broken(nItemsBroken
== outnItems
))
55 winetest_win_skip("This test broken on this platform\n");
59 todo_wine
winetest_ok(outnItems
== nItems
, "Wrong number of items\n");
61 winetest_ok(outnItems
== nItems
, "Wrong number of items\n");
62 for (x
= 0; x
<= outnItems
; x
++)
64 if (items
[x
].todo_flag
[0])
65 todo_wine
winetest_ok(outpItems
[x
].iCharPos
== items
[x
].iCharPos
, "%i:Wrong CharPos\n",x
);
67 winetest_ok(outpItems
[x
].iCharPos
== items
[x
].iCharPos
, "%i:Wrong CharPos (%i)\n",x
,outpItems
[x
].iCharPos
);
69 if (items
[x
].todo_flag
[1])
70 todo_wine
winetest_ok(outpItems
[x
].a
.fRTL
== items
[x
].fRTL
, "%i:Wrong fRTL\n",x
);
72 winetest_ok(outpItems
[x
].a
.fRTL
== items
[x
].fRTL
, "%i:Wrong fRTL(%i)\n",x
,outpItems
[x
].a
.fRTL
);
73 if (items
[x
].todo_flag
[2])
74 todo_wine
winetest_ok(outpItems
[x
].a
.fLayoutRTL
== items
[x
].fLayoutRTL
, "%i:Wrong fLayoutRTL\n",x
);
76 winetest_ok(outpItems
[x
].a
.fLayoutRTL
== items
[x
].fLayoutRTL
, "%i:Wrong fLayoutRTL(%i)\n",x
,outpItems
[x
].a
.fLayoutRTL
);
77 if (items
[x
].todo_flag
[3])
78 todo_wine
winetest_ok(outpItems
[x
].a
.s
.uBidiLevel
== items
[x
].uBidiLevel
, "%i:Wrong BidiLevel\n",x
);
80 winetest_ok(outpItems
[x
].a
.s
.uBidiLevel
== items
[x
].uBidiLevel
, "%i:Wrong BidiLevel(%i)\n",x
,outpItems
[x
].a
.s
.uBidiLevel
);
82 winetest_ok(outpItems
[x
].a
.eScript
!= SCRIPT_UNDEFINED
, "%i: Undefined script\n",x
);
86 #define test_items_ok(a,b,c,d,e,f,g,h) (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_items_ok(a,b,c,d,e,f,g,h)
89 static void test_ScriptItemize( void )
91 static const WCHAR test1
[] = {'t', 'e', 's', 't',0};
92 static const itemTest t11
[2] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},4,0,0,0}};
93 static const itemTest t12
[2] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},4,0,0,0}};
95 static const WCHAR test1b
[] = {' ', ' ', ' ', ' ',0};
96 static const itemTest t1b1
[2] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},4,0,0,0}};
97 static const itemTest t1b2
[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,0}};
100 static const WCHAR test2
[] = {'1','2','3','-','5','2',0x064a,0x064f,0x0633,0x0627,0x0648,0x0650,0x064a,'7','1','.',0};
101 static const itemTest t21
[7] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},3,0,0,0},{{0,0,0,0},4,0,0,0},{{0,0,0,0},6,1,1,1},{{0,0,0,0},13,0,0,0},{{0,0,0,0},15,0,0,0},{{0,0,0,0},16,0,0,0}};
102 static const itemTest t22
[5] = {{{0,0,0,1},0,0,0,2},{{0,0,0,0},6,1,1,1},{{0,0,1,0},13,0,1,2},{{0,0,0,0},15,0,0,0},{{0,0,0,0},16,0,0,0}};
103 static const itemTest t23
[5] = {{{0,0,1,0},0,0,1,2},{{0,0,0,0},6,1,1,1},{{0,0,1,0},13,0,1,2},{{0,0,0,0},15,1,1,1},{{0,0,0,0},16,0,0,0}};
105 static const WCHAR test2b
[] = {'A','B','C','-','D','E','F',' ',0x0621,0x0623,0x0624,0};
106 static const itemTest t2b1
[5] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},3,0,0,0},{{0,0,0,0},4,0,0,0},{{0,0,0,0},8,1,1,1},{{0,0,0,0},11,0,0,0}};
107 static const itemTest t2b2
[5] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},3,0,0,2},{{0,0,0,0},4,0,0,2},{{0,0,0,0},7,1,1,1},{{0,0,0,0},11,0,0,0}};
108 static const itemTest t2b3
[3] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},7,1,1,1},{{0,0,0,0},11,0,0,0}};
111 static const WCHAR test2c
[] = {' ',0x0621,0x0623,0x0624,'A','B','C','-','D','E','F',0};
112 static const itemTest t2c1
[5] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,0},{{0,0,0,0},7,0,0,0},{{0,0,0,0},8,0,0,0},{{0,0,0,0},11,0,0,0}};
113 static const itemTest t2c2
[6] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},1,1,1,1},{{0,0,0,0},4,0,0,0},{{0,0,0,0},7,0,0,0},{{0,0,0,0},8,0,0,0},{{0,0,0,0},11,0,0,0}};
114 static const itemTest t2c3
[5] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,2},{{0,0,0,0},7,0,0,2},{{0,0,0,0},8,0,0,2},{{0,0,0,0},11,0,0,0}};
115 static const itemTest t2c4
[3] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,2},{{0,0,0,0},11,0,0,0}};
118 static const WCHAR test2d
[] = {'A','B','C','-','D','E','F',0x0621,0x0623,0x0624,' ',0};
119 static const itemTest t2d1
[5] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},3,0,0,0},{{0,0,0,0},4,0,0,0},{{0,0,0,0},7,1,1,1},{{0,0,0,0},11,0,0,0}};
120 static const itemTest t2d2
[6] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},3,0,0,0},{{0,0,0,0},4,0,0,0},{{0,0,0,0},7,1,1,1},{{0,0,0,0},10,0,0,0},{{0,0,0,0},11,0,0,0}};
121 static const itemTest t2d3
[5] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},3,0,0,2},{{0,0,0,0},4,0,0,2},{{0,0,0,0},7,1,1,1},{{0,0,0,0},11,0,0,0}};
122 static const itemTest t2d4
[3] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},7,1,1,1},{{0,0,0,0},11,0,0,0}};
125 static const WCHAR test3
[] =
126 {0x0e04,0x0e27,0x0e32,0x0e21,0x0e1e,0x0e22,0x0e32,0x0e22,0x0e32, 0x0e21
127 ,0x0e2d,0x0e22,0x0e39,0x0e48,0x0e17,0x0e35,0x0e48,0x0e44,0x0e2b,0x0e19
128 ,0x0e04,0x0e27,0x0e32,0x0e21,0x0e2a, 0x0e33,0x0e40,0x0e23,0x0e47,0x0e08,
129 0x0e2d,0x0e22,0x0e39,0x0e48,0x0e17,0x0e35,0x0e48,0x0e19,0x0e31,0x0e48,0x0e19,0};
131 static const itemTest t31
[2] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},41,0,0,0}};
132 static const itemTest t32
[2] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},41,0,0,0}};
134 static const WCHAR test4
[] = {'1','2','3','-','5','2',' ','i','s',' ','7','1','.',0};
136 static const itemTest t41
[6] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},3,0,0,0},{{0,0,0,0},4,0,0,0},{{0,0,0,0},7,0,0,0},{{0,0,0,0},10,0,0,0},{{0,0,0,0},12,0,0,0}};
137 static const itemTest t42
[5] = {{{0,0,1,0},0,0,1,2},{{0,0,0,0},6,1,1,1},{{0,0,0,0},7,0,0,2},{{0,0,0,0},10,0,0,2},{{0,0,0,0},12,0,0,0}};
138 static const itemTest t43
[4] = {{{0,0,1,0},0,0,1,2},{{0,0,0,0},6,1,1,1},{{0,0,0,0},7,0,0,2},{{0,0,0,0},12,0,0,0}};
141 static const WCHAR test5
[] =
142 {0x0627,0x0644,0x0635,0x0651,0x0650,0x062d,0x0629,0x064f,' ',0x062a,0x064e,
143 0x0627,0x062c,0x064c,' ',0x0639,0x064e,0x0644,0x0649,' ',
144 0x0631,0x064f,0x0624,0x0648,0x0633,0x0650,' ',0x0627,0x0644
145 ,0x0623,0x0635,0x0650,0x062d,0x0651,0x064e,0x0627,0x0621,0x0650,0};
146 static const itemTest t51
[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},38,0,0,0}};
149 static const WCHAR test6
[] = {0x05e9, 0x05dc, 0x05d5, 0x05dd, '.',0};
150 static const itemTest t61
[3] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,0},{{0,0,0,0},5,0,0,0}};
151 static const itemTest t62
[3] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,1,1,1},{{0,0,0,0},5,0,0,0}};
152 static const itemTest t63
[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},5,0,0,0}};
153 static const WCHAR test7
[] = {'p','a','r','t',' ','o','n','e',' ',0x05d7, 0x05dc, 0x05e7, ' ', 0x05e9, 0x05ea, 0x05d9, 0x05d9, 0x05dd, ' ','p','a','r','t',' ','t','h','r','e','e', 0};
154 static const itemTest t71
[4] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},9,1,1,1},{{0,0,0,0},19,0,0,0},{{0,0,0,0},29,0,0,0}};
155 static const itemTest t72
[4] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},9,1,1,1},{{0,0,0,0},18,0,0,0},{{0,0,0,0},29,0,0,0}};
156 static const itemTest t73
[4] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},8,1,1,1},{{0,0,0,0},19,0,0,2},{{0,0,0,0},29,0,0,0}};
157 static const WCHAR test8
[] = {0x0633, 0x0644, 0x0627, 0x0645,0};
158 static const itemTest t81
[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,0}};
160 /* Syriac (Like Arabic )*/
161 static const WCHAR test9
[] = {0x0710, 0x0712, 0x0712, 0x0714, '.',0};
162 static const itemTest t91
[3] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,0},{{0,0,0,0},5,0,0,0}};
163 static const itemTest t92
[3] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,1,1,1},{{0,0,0,0},5,0,0,0}};
164 static const itemTest t93
[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},5,0,0,0}};
166 static const WCHAR test10
[] = {0x0717, 0x0718, 0x071a, 0x071b,0};
167 static const itemTest t101
[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,0}};
169 SCRIPT_ITEM items
[15];
170 SCRIPT_CONTROL Control
;
175 memset(&Control
, 0, sizeof(Control
));
176 memset(&State
, 0, sizeof(State
));
178 hr
= ScriptItemize(NULL
, 4, 10, &Control
, &State
, items
, NULL
);
179 ok (hr
== E_INVALIDARG
, "ScriptItemize should return E_INVALIDARG if pwcInChars is NULL\n");
181 hr
= ScriptItemize(test1
, 4, 10, &Control
, &State
, NULL
, NULL
);
182 ok (hr
== E_INVALIDARG
, "ScriptItemize should return E_INVALIDARG if pItems is NULL\n");
184 hr
= ScriptItemize(test1
, 4, 1, &Control
, &State
, items
, NULL
);
185 ok (hr
== E_INVALIDARG
, "ScriptItemize should return E_INVALIDARG if cMaxItems < 2.\n");
187 hr
= ScriptItemize(test1
, 0, 10, NULL
, NULL
, items
, &nItems
);
188 ok (hr
== E_INVALIDARG
, "ScriptItemize should return E_INVALIDARG if cInChars is 0\n");
190 test_items_ok(test1
,4,NULL
,NULL
,1,t11
,FALSE
,0);
191 test_items_ok(test1b
,4,NULL
,NULL
,1,t1b1
,FALSE
,0);
192 test_items_ok(test2
,16,NULL
,NULL
,6,t21
,FALSE
,0);
193 test_items_ok(test2b
,11,NULL
,NULL
,4,t2b1
,FALSE
,0);
194 test_items_ok(test2c
,11,NULL
,NULL
,4,t2c1
,FALSE
,0);
195 test_items_ok(test2d
,11,NULL
,NULL
,4,t2d1
,FALSE
,0);
196 test_items_ok(test3
,41,NULL
,NULL
,1,t31
,FALSE
,0);
197 test_items_ok(test4
,12,NULL
,NULL
,5,t41
,FALSE
,0);
198 test_items_ok(test5
,38,NULL
,NULL
,1,t51
,FALSE
,0);
199 test_items_ok(test6
,5,NULL
,NULL
,2,t61
,FALSE
,0);
200 test_items_ok(test7
,29,NULL
,NULL
,3,t71
,FALSE
,0);
201 test_items_ok(test8
,4,NULL
,NULL
,1,t81
,FALSE
,0);
202 test_items_ok(test9
,5,NULL
,NULL
,2,t91
,FALSE
,0);
203 test_items_ok(test10
,4,NULL
,NULL
,1,t101
,FALSE
,0);
205 State
.uBidiLevel
= 0;
206 test_items_ok(test1
,4,&Control
,&State
,1,t11
,FALSE
,0);
207 test_items_ok(test1b
,4,&Control
,&State
,1,t1b1
,FALSE
,0);
208 test_items_ok(test2
,16,&Control
,&State
,4,t22
,FALSE
,0);
209 test_items_ok(test2b
,11,&Control
,&State
,4,t2b1
,FALSE
,0);
210 test_items_ok(test2c
,11,&Control
,&State
,5,t2c2
,FALSE
,0);
211 test_items_ok(test2d
,11,&Control
,&State
,5,t2d2
,FALSE
,0);
212 test_items_ok(test3
,41,&Control
,&State
,1,t31
,FALSE
,0);
213 test_items_ok(test4
,12,&Control
,&State
,5,t41
,FALSE
,0);
214 test_items_ok(test5
,38,&Control
,&State
,1,t51
,FALSE
,0);
215 test_items_ok(test6
,5,&Control
,&State
,2,t61
,FALSE
,0);
216 test_items_ok(test7
,29,&Control
,&State
,3,t72
,FALSE
,0);
217 test_items_ok(test8
,4,&Control
,&State
,1,t81
,FALSE
,0);
218 test_items_ok(test9
,5,&Control
,&State
,2,t91
,FALSE
,0);
219 test_items_ok(test10
,4,&Control
,&State
,1,t101
,FALSE
,0);
221 State
.uBidiLevel
= 1;
222 test_items_ok(test1
,4,&Control
,&State
,1,t12
,FALSE
,0);
223 test_items_ok(test1b
,4,&Control
,&State
,1,t1b2
,FALSE
,0);
224 test_items_ok(test2
,16,&Control
,&State
,4,t23
,FALSE
,0);
225 test_items_ok(test2b
,11,&Control
,&State
,4,t2b2
,FALSE
,0);
226 test_items_ok(test2c
,11,&Control
,&State
,4,t2c3
,FALSE
,0);
227 test_items_ok(test2d
,11,&Control
,&State
,4,t2d3
,FALSE
,0);
228 test_items_ok(test3
,41,&Control
,&State
,1,t32
,FALSE
,0);
229 test_items_ok(test4
,12,&Control
,&State
,4,t42
,FALSE
,0);
230 test_items_ok(test5
,38,&Control
,&State
,1,t51
,FALSE
,0);
231 test_items_ok(test6
,5,&Control
,&State
,2,t62
,FALSE
,0);
232 test_items_ok(test7
,29,&Control
,&State
,3,t73
,FALSE
,0);
233 test_items_ok(test8
,4,&Control
,&State
,1,t81
,FALSE
,0);
234 test_items_ok(test9
,5,&Control
,&State
,2,t92
,FALSE
,0);
235 test_items_ok(test10
,4,&Control
,&State
,1,t101
,FALSE
,0);
237 State
.uBidiLevel
= 1;
238 Control
.fMergeNeutralItems
= TRUE
;
239 test_items_ok(test1
,4,&Control
,&State
,1,t12
,FALSE
,0);
240 test_items_ok(test1b
,4,&Control
,&State
,1,t1b2
,FALSE
,0);
241 test_items_ok(test2
,16,&Control
,&State
,4,t23
,FALSE
,0);
242 test_items_ok(test2b
,11,&Control
,&State
,2,t2b3
,FALSE
,4);
243 test_items_ok(test2c
,11,&Control
,&State
,2,t2c4
,FALSE
,4);
244 test_items_ok(test2d
,11,&Control
,&State
,2,t2d4
,FALSE
,4);
245 test_items_ok(test3
,41,&Control
,&State
,1,t32
,FALSE
,0);
246 test_items_ok(test4
,12,&Control
,&State
,3,t43
,FALSE
,4);
247 test_items_ok(test5
,38,&Control
,&State
,1,t51
,FALSE
,0);
248 test_items_ok(test6
,5,&Control
,&State
,1,t63
,FALSE
,2);
249 test_items_ok(test7
,29,&Control
,&State
,3,t73
,FALSE
,0);
250 test_items_ok(test8
,4,&Control
,&State
,1,t81
,FALSE
,0);
251 test_items_ok(test9
,5,&Control
,&State
,1,t93
,FALSE
,2);
252 test_items_ok(test10
,4,&Control
,&State
,1,t101
,FALSE
,0);
256 static void test_ScriptShape(HDC hdc
)
258 static const WCHAR test1
[] = {'w', 'i', 'n', 'e',0};
259 static const WCHAR test2
[] = {0x202B, 'i', 'n', 0x202C,0};
261 SCRIPT_CACHE sc
= NULL
;
262 WORD glyphs
[4], glyphs2
[4], logclust
[4];
263 SCRIPT_VISATTR attrs
[4];
264 SCRIPT_ITEM items
[2];
267 hr
= ScriptItemize(test1
, 4, 2, NULL
, NULL
, items
, NULL
);
268 ok(!hr
, "ScriptItemize should return S_OK not %08x\n", hr
);
269 ok(items
[0].a
.fNoGlyphIndex
== FALSE
, "fNoGlyphIndex TRUE\n");
271 hr
= ScriptShape(hdc
, &sc
, test1
, 4, 4, &items
[0].a
, glyphs
, NULL
, NULL
, &nb
);
272 ok(hr
== E_INVALIDARG
, "ScriptShape should return E_INVALIDARG not %08x\n", hr
);
274 hr
= ScriptShape(hdc
, &sc
, test1
, 4, 4, &items
[0].a
, glyphs
, NULL
, attrs
, NULL
);
275 ok(hr
== E_INVALIDARG
, "ScriptShape should return E_INVALIDARG not %08x\n", hr
);
277 hr
= ScriptShape(NULL
, &sc
, test1
, 4, 4, &items
[0].a
, glyphs
, NULL
, attrs
, &nb
);
278 ok(hr
== E_PENDING
, "ScriptShape should return E_PENDING not %08x\n", hr
);
280 hr
= ScriptShape(hdc
, &sc
, test1
, 4, 4, &items
[0].a
, glyphs
, NULL
, attrs
, &nb
);
281 ok(broken(hr
== S_OK
) ||
282 hr
== E_INVALIDARG
|| /* Vista, W2K8 */
283 hr
== E_FAIL
, /* WIN7 */
284 "ScriptShape should return E_FAIL or E_INVALIDARG, not %08x\n", hr
);
285 ok(items
[0].a
.fNoGlyphIndex
== FALSE
, "fNoGlyphIndex TRUE\n");
287 hr
= ScriptShape(hdc
, &sc
, test1
, 4, 4, &items
[0].a
, glyphs
, logclust
, attrs
, &nb
);
288 ok(!hr
, "ScriptShape should return S_OK not %08x\n", hr
);
289 ok(items
[0].a
.fNoGlyphIndex
== FALSE
, "fNoGlyphIndex TRUE\n");
292 memset(glyphs
,-1,sizeof(glyphs
));
293 memset(logclust
,-1,sizeof(logclust
));
294 memset(attrs
,-1,sizeof(attrs
));
295 hr
= ScriptShape(NULL
, &sc
, test1
, 4, 4, &items
[0].a
, glyphs
, logclust
, attrs
, &nb
);
296 ok(!hr
, "ScriptShape should return S_OK not %08x\n", hr
);
297 ok(nb
== 4, "Wrong number of items\n");
298 ok(logclust
[0] == 0, "clusters out of order\n");
299 ok(logclust
[1] == 1, "clusters out of order\n");
300 ok(logclust
[2] == 2, "clusters out of order\n");
301 ok(logclust
[3] == 3, "clusters out of order\n");
302 ok(attrs
[0].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
303 ok(attrs
[1].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
304 ok(attrs
[2].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
305 ok(attrs
[3].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
306 ok(attrs
[0].fClusterStart
== 1, "fClusterStart incorrect\n");
307 ok(attrs
[1].fClusterStart
== 1, "fClusterStart incorrect\n");
308 ok(attrs
[2].fClusterStart
== 1, "fClusterStart incorrect\n");
309 ok(attrs
[3].fClusterStart
== 1, "fClusterStart incorrect\n");
310 ok(attrs
[0].fDiacritic
== 0, "fDiacritic incorrect\n");
311 ok(attrs
[1].fDiacritic
== 0, "fDiacritic incorrect\n");
312 ok(attrs
[2].fDiacritic
== 0, "fDiacritic incorrect\n");
313 ok(attrs
[3].fDiacritic
== 0, "fDiacritic incorrect\n");
314 ok(attrs
[0].fZeroWidth
== 0, "fZeroWidth incorrect\n");
315 ok(attrs
[1].fZeroWidth
== 0, "fZeroWidth incorrect\n");
316 ok(attrs
[2].fZeroWidth
== 0, "fZeroWidth incorrect\n");
317 ok(attrs
[3].fZeroWidth
== 0, "fZeroWidth incorrect\n");
319 ScriptFreeCache(&sc
);
322 memset(glyphs2
,-1,sizeof(glyphs2
));
323 memset(logclust
,-1,sizeof(logclust
));
324 memset(attrs
,-1,sizeof(attrs
));
325 hr
= ScriptShape(hdc
, &sc
, test2
, 4, 4, &items
[0].a
, glyphs2
, logclust
, attrs
, &nb
);
326 ok(hr
== S_OK
, "ScriptShape should return S_OK not %08x\n", hr
);
327 ok(nb
== 4, "Wrong number of items\n");
328 ok(glyphs2
[0] == 0 || broken(glyphs2
[0] == 0x80), "Incorrect glyph for 0x202B\n");
329 ok(glyphs2
[3] == 0 || broken(glyphs2
[3] == 0x80), "Incorrect glyph for 0x202C\n");
330 ok(logclust
[0] == 0, "clusters out of order\n");
331 ok(logclust
[1] == 1, "clusters out of order\n");
332 ok(logclust
[2] == 2, "clusters out of order\n");
333 ok(logclust
[3] == 3, "clusters out of order\n");
334 ok(attrs
[0].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
335 ok(attrs
[1].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
336 ok(attrs
[2].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
337 ok(attrs
[3].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
338 ok(attrs
[0].fClusterStart
== 1, "fClusterStart incorrect\n");
339 ok(attrs
[1].fClusterStart
== 1, "fClusterStart incorrect\n");
340 ok(attrs
[2].fClusterStart
== 1, "fClusterStart incorrect\n");
341 ok(attrs
[3].fClusterStart
== 1, "fClusterStart incorrect\n");
342 ok(attrs
[0].fDiacritic
== 0, "fDiacritic incorrect\n");
343 ok(attrs
[1].fDiacritic
== 0, "fDiacritic incorrect\n");
344 ok(attrs
[2].fDiacritic
== 0, "fDiacritic incorrect\n");
345 ok(attrs
[3].fDiacritic
== 0, "fDiacritic incorrect\n");
346 ok(attrs
[0].fZeroWidth
== 0, "fZeroWidth incorrect\n");
347 ok(attrs
[1].fZeroWidth
== 0, "fZeroWidth incorrect\n");
348 ok(attrs
[2].fZeroWidth
== 0, "fZeroWidth incorrect\n");
349 ok(attrs
[3].fZeroWidth
== 0, "fZeroWidth incorrect\n");
351 /* modify LTR to RTL */
353 memset(glyphs2
,-1,sizeof(glyphs2
));
354 memset(logclust
,-1,sizeof(logclust
));
355 memset(attrs
,-1,sizeof(attrs
));
356 hr
= ScriptShape(hdc
, &sc
, test1
, 4, 4, &items
[0].a
, glyphs2
, logclust
, attrs
, &nb
);
357 ok(!hr
, "ScriptShape should return S_OK not %08x\n", hr
);
358 ok(nb
== 4, "Wrong number of items\n");
359 ok(glyphs2
[0] == glyphs
[3], "Glyphs not reordered properly\n");
360 ok(glyphs2
[1] == glyphs
[2], "Glyphs not reordered properly\n");
361 ok(glyphs2
[2] == glyphs
[1], "Glyphs not reordered properly\n");
362 ok(glyphs2
[3] == glyphs
[0], "Glyphs not reordered properly\n");
363 ok(logclust
[0] == 3, "clusters out of order\n");
364 ok(logclust
[1] == 2, "clusters out of order\n");
365 ok(logclust
[2] == 1, "clusters out of order\n");
366 ok(logclust
[3] == 0, "clusters out of order\n");
367 ok(attrs
[0].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
368 ok(attrs
[1].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
369 ok(attrs
[2].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
370 ok(attrs
[3].uJustification
== SCRIPT_JUSTIFY_CHARACTER
, "uJustification incorrect\n");
371 ok(attrs
[0].fClusterStart
== 1, "fClusterStart incorrect\n");
372 ok(attrs
[1].fClusterStart
== 1, "fClusterStart incorrect\n");
373 ok(attrs
[2].fClusterStart
== 1, "fClusterStart incorrect\n");
374 ok(attrs
[3].fClusterStart
== 1, "fClusterStart incorrect\n");
375 ok(attrs
[0].fDiacritic
== 0, "fDiacritic incorrect\n");
376 ok(attrs
[1].fDiacritic
== 0, "fDiacritic incorrect\n");
377 ok(attrs
[2].fDiacritic
== 0, "fDiacritic incorrect\n");
378 ok(attrs
[3].fDiacritic
== 0, "fDiacritic incorrect\n");
379 ok(attrs
[0].fZeroWidth
== 0, "fZeroWidth incorrect\n");
380 ok(attrs
[1].fZeroWidth
== 0, "fZeroWidth incorrect\n");
381 ok(attrs
[2].fZeroWidth
== 0, "fZeroWidth incorrect\n");
382 ok(attrs
[3].fZeroWidth
== 0, "fZeroWidth incorrect\n");
384 ScriptFreeCache(&sc
);
387 static void test_ScriptPlace(HDC hdc
)
389 static const WCHAR test1
[] = {'t', 'e', 's', 't',0};
392 SCRIPT_CACHE sc
= NULL
;
393 WORD glyphs
[4], logclust
[4];
394 SCRIPT_VISATTR attrs
[4];
395 SCRIPT_ITEM items
[2];
400 hr
= ScriptItemize(test1
, 4, 2, NULL
, NULL
, items
, NULL
);
401 ok(!hr
, "ScriptItemize should return S_OK not %08x\n", hr
);
402 ok(items
[0].a
.fNoGlyphIndex
== FALSE
, "fNoGlyphIndex TRUE\n");
404 hr
= ScriptShape(hdc
, &sc
, test1
, 4, 4, &items
[0].a
, glyphs
, logclust
, attrs
, &nb
);
405 ok(!hr
, "ScriptShape should return S_OK not %08x\n", hr
);
406 ok(items
[0].a
.fNoGlyphIndex
== FALSE
, "fNoGlyphIndex TRUE\n");
408 hr
= ScriptPlace(hdc
, &sc
, glyphs
, 4, NULL
, &items
[0].a
, widths
, NULL
, NULL
);
409 ok(hr
== E_INVALIDARG
, "ScriptPlace should return E_INVALIDARG not %08x\n", hr
);
411 hr
= ScriptPlace(NULL
, &sc
, glyphs
, 4, attrs
, &items
[0].a
, widths
, NULL
, NULL
);
412 ok(broken(hr
== E_PENDING
) ||
413 hr
== E_INVALIDARG
|| /* Vista, W2K8 */
414 hr
== E_FAIL
, /* WIN7 */
415 "ScriptPlace should return E_FAIL or E_INVALIDARG, not %08x\n", hr
);
417 hr
= ScriptPlace(NULL
, &sc
, glyphs
, 4, attrs
, &items
[0].a
, widths
, offset
, NULL
);
418 ok(hr
== E_PENDING
, "ScriptPlace should return E_PENDING not %08x\n", hr
);
420 hr
= ScriptPlace(NULL
, &sc
, glyphs
, 4, attrs
, &items
[0].a
, widths
, NULL
, abc
);
421 ok(broken(hr
== E_PENDING
) ||
422 hr
== E_INVALIDARG
|| /* Vista, W2K8 */
423 hr
== E_FAIL
, /* WIN7 */
424 "ScriptPlace should return E_FAIL or E_INVALIDARG, not %08x\n", hr
);
426 hr
= ScriptPlace(hdc
, &sc
, glyphs
, 4, attrs
, &items
[0].a
, widths
, offset
, NULL
);
427 ok(!hr
, "ScriptPlace should return S_OK not %08x\n", hr
);
428 ok(items
[0].a
.fNoGlyphIndex
== FALSE
, "fNoGlyphIndex TRUE\n");
430 ret
= ExtTextOutW(hdc
, 1, 1, 0, NULL
, glyphs
, 4, widths
);
431 ok(ret
, "ExtTextOutW should return TRUE\n");
433 ScriptFreeCache(&sc
);
436 static void test_ScriptItemIzeShapePlace(HDC hdc
, unsigned short pwOutGlyphs
[256])
440 const SCRIPT_PROPERTIES
**ppSp
;
444 SCRIPT_ITEM pItem
[255];
446 WCHAR TestItem1
[] = {'T', 'e', 's', 't', 'a', 0};
447 WCHAR TestItem2
[] = {'T', 'e', 's', 't', 'b', 0};
448 WCHAR TestItem3
[] = {'T', 'e', 's', 't', 'c',' ','1','2','3',' ',' ','e','n','d',0};
449 WCHAR TestItem4
[] = {'T', 'e', 's', 't', 'd',' ',0x0684,0x0694,0x06a4,' ',' ','\r','\n','e','n','d',0};
450 WCHAR TestItem5
[] = {0x0684,'T','e','s','t','e',' ',0x0684,0x0694,0x06a4,' ',' ','e','n','d',0};
451 WCHAR TestItem6
[] = {'T', 'e', 's', 't', 'f',' ',' ',' ','\r','\n','e','n','d',0};
456 unsigned short pwOutGlyphs1
[256];
457 unsigned short pwOutGlyphs2
[256];
458 unsigned short pwLogClust
[256];
459 SCRIPT_VISATTR psva
[256];
462 GOFFSET pGoffset
[256];
466 /* Start testing usp10 functions */
467 /* This test determines that the pointer returned by ScriptGetProperties is valid
468 * by checking a known value in the table */
469 hr
= ScriptGetProperties(&ppSp
, &iMaxProps
);
470 trace("number of script properties %d\n", iMaxProps
);
471 ok (iMaxProps
> 0, "Number of scripts returned should not be 0\n");
473 ok( ppSp
[0]->langid
== 0, "Langid[0] not = to 0\n"); /* Check a known value to ensure */
476 /* This is a valid test that will cause parsing to take place */
479 hr
= ScriptItemize(TestItem1
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
480 ok (hr
== 0, "ScriptItemize should return 0, returned %08x\n", hr
);
481 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
483 ok (pcItems
> 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
485 ok (pItem
[0].iCharPos
== 0 && pItem
[1].iCharPos
== cInChars
,
486 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
487 pItem
[0].iCharPos
, cInChars
, pItem
[1].iCharPos
);
489 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
490 * ie. ScriptItemize has succeeded and that pItem has been set */
494 psc
= NULL
; /* must be null on first call */
496 cMaxGlyphs
= cInChars
;
497 hr
= ScriptShape(NULL
, &psc
, TestItem1
, cChars
,
498 cMaxGlyphs
, &pItem
[0].a
,
499 pwOutGlyphs1
, pwLogClust
, psva
, &pcGlyphs
);
500 ok (hr
== E_PENDING
, "If psc is NULL (%08x) the E_PENDING should be returned\n", hr
);
502 hr
= ScriptShape(hdc
, &psc
, TestItem1
, cChars
,
503 cMaxGlyphs
, &pItem
[0].a
,
504 pwOutGlyphs1
, pwLogClust
, psva
, &pcGlyphs
);
505 ok (hr
== E_OUTOFMEMORY
, "If not enough output area cChars (%d) is > than CMaxGlyphs "
506 "(%d) but not E_OUTOFMEMORY\n",
509 hr
= ScriptShape(hdc
, &psc
, TestItem1
, cChars
,
510 cMaxGlyphs
, &pItem
[0].a
,
511 pwOutGlyphs1
, pwLogClust
, psva
, &pcGlyphs
);
512 ok (hr
== 0, "ScriptShape should return 0 not (%08x)\n", hr
);
513 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
514 ok (pcGlyphs
== cChars
, "Chars in (%d) should equal Glyphs out (%d)\n", cChars
, pcGlyphs
);
516 hr
= ScriptPlace(hdc
, &psc
, pwOutGlyphs1
, pcGlyphs
, psva
, &pItem
[0].a
, piAdvance
,
518 ok (hr
== 0, "ScriptPlace should return 0 not (%08x)\n", hr
);
519 hr
= ScriptPlace(NULL
, &psc
, pwOutGlyphs1
, pcGlyphs
, psva
, &pItem
[0].a
, piAdvance
,
521 ok (hr
== 0, "ScriptPlace should return 0 not (%08x)\n", hr
);
522 for (cnt
=0; cnt
< pcGlyphs
; cnt
++)
523 pwOutGlyphs
[cnt
] = pwOutGlyphs1
[cnt
]; /* Send to next function */
526 /* This test will check to make sure that SCRIPT_CACHE is reused and that not translation *
527 * takes place if fNoGlyphIndex is set. */
531 hr
= ScriptItemize(TestItem2
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
532 ok (hr
== 0, "ScriptItemize should return 0, returned %08x\n", hr
);
533 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
535 ok (pItem
[0].iCharPos
== 0 && pItem
[1].iCharPos
== cInChars
,
536 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
537 pItem
[0].iCharPos
, cInChars
, pItem
[1].iCharPos
);
538 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue */
542 pItem
[0].a
.fNoGlyphIndex
= 1; /* say no translate */
543 hr
= ScriptShape(NULL
, &psc
, TestItem2
, cChars
,
544 cMaxGlyphs
, &pItem
[0].a
,
545 pwOutGlyphs2
, pwLogClust
, psva
, &pcGlyphs
);
546 ok (hr
!= E_PENDING
, "If psc should not be NULL (%08x) and the E_PENDING should be returned\n", hr
);
547 ok (hr
== 0, "ScriptShape should return 0 not (%08x)\n", hr
);
548 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
549 ok (pcGlyphs
== cChars
, "Chars in (%d) should equal Glyphs out (%d)\n", cChars
, pcGlyphs
);
550 for (cnt
=0; cnt
< cChars
&& TestItem2
[cnt
] == pwOutGlyphs2
[cnt
]; cnt
++) {}
551 ok (cnt
== cChars
, "Translation to place when told not to. WCHAR %d - %04x != %04x\n",
552 cnt
, TestItem2
[cnt
], pwOutGlyphs2
[cnt
]);
554 hr
= ScriptPlace(hdc
, &psc
, pwOutGlyphs2
, pcGlyphs
, psva
, &pItem
[0].a
, piAdvance
,
556 ok (hr
== 0, "ScriptPlace should return 0 not (%08x)\n", hr
);
559 hr
= ScriptFreeCache( &psc
);
560 ok (!psc
, "psc is not null after ScriptFreeCache\n");
564 /* This is a valid test that will cause parsing to take place and create 3 script_items */
565 cInChars
= (sizeof(TestItem3
)/2)-1;
567 hr
= ScriptItemize(TestItem3
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
568 ok (hr
== 0, "ScriptItemize should return 0, returned %08x\n", hr
);
571 ok (pcItems
== 3, "The number of SCRIPT_ITEMS should be 3 not %d\n", pcItems
);
574 ok (pItem
[0].iCharPos
== 0 && pItem
[1].iCharPos
== 6,
575 "Start pos [0] not = 0 (%d) or end pos [1] not = %d\n",
576 pItem
[0].iCharPos
, pItem
[1].iCharPos
);
577 ok (pItem
[1].iCharPos
== 6 && pItem
[2].iCharPos
== 11,
578 "Start pos [1] not = 6 (%d) or end pos [2] not = 11 (%d)\n",
579 pItem
[1].iCharPos
, pItem
[2].iCharPos
);
580 ok (pItem
[2].iCharPos
== 11 && pItem
[3].iCharPos
== cInChars
,
581 "Start pos [2] not = 11 (%d) or end [3] pos not = 14 (%d), cInChars = %d\n",
582 pItem
[2].iCharPos
, pItem
[3].iCharPos
, cInChars
);
586 /* This is a valid test that will cause parsing to take place and create 5 script_items */
587 cInChars
= (sizeof(TestItem4
)/2)-1;
589 hr
= ScriptItemize(TestItem4
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
590 ok (hr
== 0, "ScriptItemize should return 0, returned %08x\n", hr
);
593 ok (pcItems
== 5, "The number of SCRIPT_ITEMS should be 5 not %d\n", pcItems
);
596 ok (pItem
[0].iCharPos
== 0 && pItem
[1].iCharPos
== 6,
597 "Start pos [0] not = 0 (%d) or end pos [1] not = %d\n",
598 pItem
[0].iCharPos
, pItem
[1].iCharPos
);
599 ok (pItem
[0].a
.s
.uBidiLevel
== 0, "Should have been bidi=0 not %d\n",
600 pItem
[0].a
.s
.uBidiLevel
);
601 ok (pItem
[1].iCharPos
== 6 && pItem
[2].iCharPos
== 11,
602 "Start pos [1] not = 6 (%d) or end pos [2] not = 11 (%d)\n",
603 pItem
[1].iCharPos
, pItem
[2].iCharPos
);
604 ok (pItem
[1].a
.s
.uBidiLevel
== 1, "Should have been bidi=1 not %d\n",
605 pItem
[1].a
.s
.uBidiLevel
);
606 ok (pItem
[2].iCharPos
== 11 && pItem
[3].iCharPos
== 12,
607 "Start pos [2] not = 11 (%d) or end [3] pos not = 12 (%d)\n",
608 pItem
[2].iCharPos
, pItem
[3].iCharPos
);
609 ok (pItem
[2].a
.s
.uBidiLevel
== 0, "Should have been bidi=0 not %d\n",
610 pItem
[2].a
.s
.uBidiLevel
);
611 ok (pItem
[3].iCharPos
== 12 && pItem
[4].iCharPos
== 13,
612 "Start pos [3] not = 12 (%d) or end [4] pos not = 13 (%d)\n",
613 pItem
[3].iCharPos
, pItem
[4].iCharPos
);
614 ok (pItem
[3].a
.s
.uBidiLevel
== 0, "Should have been bidi=0 not %d\n",
615 pItem
[3].a
.s
.uBidiLevel
);
616 ok (pItem
[4].iCharPos
== 13 && pItem
[5].iCharPos
== cInChars
,
617 "Start pos [4] not = 13 (%d) or end [5] pos not = 16 (%d), cInChars = %d\n",
618 pItem
[4].iCharPos
, pItem
[5].iCharPos
, cInChars
);
623 * This test is for when the first unicode character requires bidi support
625 cInChars
= (sizeof(TestItem5
)-1)/sizeof(WCHAR
);
626 hr
= ScriptItemize(TestItem5
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
627 ok (hr
== 0, "ScriptItemize should return 0, returned %08x\n", hr
);
628 ok (pcItems
== 4, "There should have been 4 items, found %d\n", pcItems
);
629 ok (pItem
[0].a
.s
.uBidiLevel
== 1, "The first character should have been bidi=1 not %d\n",
630 pItem
[0].a
.s
.uBidiLevel
);
632 /* This test checks to make sure that the test to see if there are sufficient buffers to store *
633 * the pointer to the last char works. Note that windows often needs a greater number of *
634 * SCRIPT_ITEMS to process a string than is returned in pcItems. */
635 cInChars
= (sizeof(TestItem6
)/2)-1;
637 hr
= ScriptItemize(TestItem6
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
638 ok (hr
== E_OUTOFMEMORY
, "ScriptItemize should return E_OUTOFMEMORY, returned %08x\n", hr
);
642 static void test_ScriptGetCMap(HDC hdc
, unsigned short pwOutGlyphs
[256])
645 SCRIPT_CACHE psc
= NULL
;
648 unsigned short pwOutGlyphs2
[256];
649 unsigned short pwOutGlyphs3
[256];
653 static const WCHAR TestItem1
[] = {'T', 'e', 's', 't', 'a', 0};
654 static const WCHAR TestItem2
[] = {0x202B, 'i', 'n', 0x202C,0};
655 static const WCHAR TestItem3
[] = {'a','b','c','d','(','<','{','[',0x2039,0};
656 static const WCHAR TestItem3b
[] = {'a','b','c','d',')','>','}',']',0x203A,0};
658 /* Check to make sure that SCRIPT_CACHE gets allocated ok */
660 cInChars
= cChars
= 5;
661 /* Some sanity checks for ScriptGetCMap */
663 hr
= ScriptGetCMap(NULL
, NULL
, NULL
, 0, 0, NULL
);
664 ok( hr
== E_INVALIDARG
, "(NULL,NULL,NULL,0,0,NULL), "
665 "expected E_INVALIDARG, got %08x\n", hr
);
667 hr
= ScriptGetCMap(NULL
, NULL
, TestItem1
, cInChars
, dwFlags
, pwOutGlyphs3
);
668 ok( hr
== E_INVALIDARG
, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
669 "expected E_INVALIDARG, got %08x\n", hr
);
671 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
673 hr
= ScriptGetCMap(NULL
, &psc
, TestItem1
, cInChars
, 0, pwOutGlyphs3
);
674 ok( hr
== E_PENDING
, "(NULL,&psc,NULL,0,0,NULL), expected E_PENDING, "
676 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
678 /* Set psc to NULL but add hdc, to be able to check if a pointer is returned in psc */
680 hr
= ScriptGetCMap(hdc
, &psc
, TestItem1
, cInChars
, 0, pwOutGlyphs3
);
681 ok( hr
== S_OK
, "ScriptGetCMap(NULL,&psc,NULL,0,0,NULL), expected S_OK, "
683 ok( psc
!= NULL
, "ScritpGetCMap expected psc to be not NULL\n");
684 ScriptFreeCache( &psc
);
686 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
688 hr
= ScriptGetCMap(NULL
, &psc
, TestItem1
, cInChars
, dwFlags
, pwOutGlyphs3
);
689 ok( hr
== E_PENDING
, "(NULL,&psc,), expected E_PENDING, got %08x\n", hr
);
690 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
691 /* Check to see if the results are the same as those returned by ScriptShape */
692 hr
= ScriptGetCMap(hdc
, &psc
, TestItem1
, cInChars
, dwFlags
, pwOutGlyphs3
);
693 ok (hr
== 0, "ScriptGetCMap should return 0 not (%08x)\n", hr
);
694 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
695 for (cnt
=0; cnt
< cChars
&& pwOutGlyphs
[cnt
] == pwOutGlyphs3
[cnt
]; cnt
++) {}
696 ok (cnt
== cInChars
, "Translation not correct. WCHAR %d - %04x != %04x\n",
697 cnt
, pwOutGlyphs
[cnt
], pwOutGlyphs3
[cnt
]);
699 hr
= ScriptFreeCache( &psc
);
700 ok (!psc
, "psc is not null after ScriptFreeCache\n");
702 cInChars
= cChars
= 4;
703 hr
= ScriptGetCMap(hdc
, &psc
, TestItem2
, cInChars
, dwFlags
, pwOutGlyphs3
);
704 ok (hr
== S_FALSE
, "ScriptGetCMap should return S_FALSE not (%08x)\n", hr
);
705 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
706 ok(pwOutGlyphs3
[0] == 0 || broken(pwOutGlyphs3
[0] == 0x80), "Glyph 0 should be default glyph\n");
707 ok(pwOutGlyphs3
[3] == 0 || broken(pwOutGlyphs3
[0] == 0x80), "Glyph 0 should be default glyph\n");
710 cInChars
= cChars
= 9;
711 hr
= ScriptGetCMap(hdc
, &psc
, TestItem3b
, cInChars
, dwFlags
, pwOutGlyphs2
);
712 ok (hr
== S_OK
, "ScriptGetCMap should return S_OK not (%08x)\n", hr
);
713 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
715 cInChars
= cChars
= 9;
717 hr
= ScriptGetCMap(hdc
, &psc
, TestItem3
, cInChars
, dwFlags
, pwOutGlyphs3
);
718 ok (hr
== S_OK
, "ScriptGetCMap should return S_OK not (%08x)\n", hr
);
719 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
720 ok(pwOutGlyphs3
[0] == pwOutGlyphs2
[0], "glyph incorrectly altered\n");
721 ok(pwOutGlyphs3
[1] == pwOutGlyphs2
[1], "glyph incorreclty altered\n");
722 ok(pwOutGlyphs3
[2] == pwOutGlyphs2
[2], "glyph incorreclty altered\n");
723 ok(pwOutGlyphs3
[3] == pwOutGlyphs2
[3], "glyph incorreclty altered\n");
724 ok(pwOutGlyphs3
[4] == pwOutGlyphs2
[4], "glyph not mirrored correctly\n");
725 ok(pwOutGlyphs3
[5] == pwOutGlyphs2
[5], "glyph not mirrored correctly\n");
726 ok(pwOutGlyphs3
[6] == pwOutGlyphs2
[6], "glyph not mirrored correctly\n");
727 ok(pwOutGlyphs3
[7] == pwOutGlyphs2
[7], "glyph not mirrored correctly\n");
728 ok(pwOutGlyphs3
[8] == pwOutGlyphs2
[8], "glyph not mirrored correctly\n");
730 hr
= ScriptFreeCache( &psc
);
731 ok (!psc
, "psc is not null after ScriptFreeCache\n");
734 static void test_ScriptGetFontProperties(HDC hdc
)
737 SCRIPT_CACHE psc
,old_psc
;
738 SCRIPT_FONTPROPERTIES sfp
;
740 /* Some sanity checks for ScriptGetFontProperties */
742 hr
= ScriptGetFontProperties(NULL
,NULL
,NULL
);
743 ok( hr
== E_INVALIDARG
, "(NULL,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr
);
745 hr
= ScriptGetFontProperties(NULL
,NULL
,&sfp
);
746 ok( hr
== E_INVALIDARG
, "(NULL,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr
);
748 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
750 hr
= ScriptGetFontProperties(NULL
,&psc
,NULL
);
751 ok( hr
== E_INVALIDARG
, "(NULL,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr
);
752 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
754 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
756 hr
= ScriptGetFontProperties(NULL
,&psc
,&sfp
);
757 ok( hr
== E_PENDING
, "(NULL,&psc,&sfp), expected E_PENDING, got %08x\n", hr
);
758 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
760 hr
= ScriptGetFontProperties(hdc
,NULL
,NULL
);
761 ok( hr
== E_INVALIDARG
, "(hdc,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr
);
763 hr
= ScriptGetFontProperties(hdc
,NULL
,&sfp
);
764 ok( hr
== E_INVALIDARG
, "(hdc,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr
);
766 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
768 hr
= ScriptGetFontProperties(hdc
,&psc
,NULL
);
769 ok( hr
== E_INVALIDARG
, "(hdc,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr
);
770 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
772 /* Pass an invalid sfp */
774 sfp
.cBytes
= sizeof(SCRIPT_FONTPROPERTIES
) - 1;
775 hr
= ScriptGetFontProperties(hdc
,&psc
,&sfp
);
776 ok( hr
== E_INVALIDARG
, "(hdc,&psc,&sfp) invalid, expected E_INVALIDARG, got %08x\n", hr
);
777 ok( psc
!= NULL
, "Expected a pointer in psc, got NULL\n");
778 ScriptFreeCache(&psc
);
779 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
781 /* Give it the correct cBytes, we don't care about what's coming back */
782 sfp
.cBytes
= sizeof(SCRIPT_FONTPROPERTIES
);
784 hr
= ScriptGetFontProperties(hdc
,&psc
,&sfp
);
785 ok( hr
== S_OK
, "(hdc,&psc,&sfp) partly initialized, expected S_OK, got %08x\n", hr
);
786 ok( psc
!= NULL
, "Expected a pointer in psc, got NULL\n");
788 /* Save the psc pointer */
790 /* Now a NULL hdc again */
791 hr
= ScriptGetFontProperties(NULL
,&psc
,&sfp
);
792 ok( hr
== S_OK
, "(NULL,&psc,&sfp), expected S_OK, got %08x\n", hr
);
793 ok( psc
== old_psc
, "Expected psc not to be changed, was %p is now %p\n", old_psc
, psc
);
794 ScriptFreeCache(&psc
);
795 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
798 static void test_ScriptTextOut(HDC hdc
)
804 SCRIPT_ITEM pItem
[255];
806 WCHAR TestItem1
[] = {'T', 'e', 's', 't', 'a', 0};
811 unsigned short pwOutGlyphs1
[256];
812 WORD pwLogClust
[256];
813 SCRIPT_VISATTR psva
[256];
816 GOFFSET pGoffset
[256];
821 BOOL fTrailing
= FALSE
;
822 SCRIPT_LOGATTR
*psla
;
823 SCRIPT_LOGATTR sla
[256];
825 /* This is a valid test that will cause parsing to take place */
828 hr
= ScriptItemize(TestItem1
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
829 ok (hr
== 0, "ScriptItemize should return 0, returned %08x\n", hr
);
830 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
832 ok (pcItems
> 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
834 ok (pItem
[0].iCharPos
== 0 && pItem
[1].iCharPos
== cInChars
,
835 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
836 pItem
[0].iCharPos
, cInChars
, pItem
[1].iCharPos
);
838 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
839 * ie. ScriptItemize has succeeded and that pItem has been set */
843 psc
= NULL
; /* must be null on first call */
845 cMaxGlyphs
= cInChars
;
847 hr
= ScriptShape(hdc
, &psc
, TestItem1
, cChars
,
848 cMaxGlyphs
, &pItem
[0].a
,
849 pwOutGlyphs1
, pwLogClust
, psva
, &pcGlyphs
);
850 ok (hr
== 0, "ScriptShape should return 0 not (%08x)\n", hr
);
851 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
852 ok (pcGlyphs
== cChars
, "Chars in (%d) should equal Glyphs out (%d)\n", cChars
, pcGlyphs
);
854 /* Note hdc is needed as glyph info is not yet in psc */
855 hr
= ScriptPlace(hdc
, &psc
, pwOutGlyphs1
, pcGlyphs
, psva
, &pItem
[0].a
, piAdvance
,
857 ok (hr
== 0, "Should return 0 not (%08x)\n", hr
);
858 ScriptFreeCache(&psc
); /* Get rid of psc for next test set */
859 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
861 hr
= ScriptTextOut(NULL
, NULL
, 0, 0, 0, NULL
, NULL
, NULL
, 0, NULL
, 0, NULL
, NULL
, NULL
);
862 ok (hr
== E_INVALIDARG
, "Should return 0 not (%08x)\n", hr
);
864 hr
= ScriptTextOut(NULL
, NULL
, 0, 0, 0, NULL
, &pItem
[0].a
, NULL
, 0, pwOutGlyphs1
, pcGlyphs
,
865 piAdvance
, NULL
, pGoffset
);
866 ok( hr
== E_INVALIDARG
, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
867 "expected E_INVALIDARG, got %08x\n", hr
);
869 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
871 hr
= ScriptTextOut(NULL
, &psc
, 0, 0, 0, NULL
, NULL
, NULL
, 0, NULL
, 0,
873 ok( hr
== E_INVALIDARG
, "(NULL,&psc,NULL,0,0,0,NULL,), expected E_INVALIDARG, "
875 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
877 /* hdc is required for this one rather than the usual optional */
879 hr
= ScriptTextOut(NULL
, &psc
, 0, 0, 0, NULL
, &pItem
[0].a
, NULL
, 0, pwOutGlyphs1
, pcGlyphs
,
880 piAdvance
, NULL
, pGoffset
);
881 ok( hr
== E_INVALIDARG
, "(NULL,&psc,), expected E_INVALIDARG, got %08x\n", hr
);
882 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
884 /* Set that it returns 0 status */
885 hr
= ScriptTextOut(hdc
, &psc
, 0, 0, 0, NULL
, &pItem
[0].a
, NULL
, 0, pwOutGlyphs1
, pcGlyphs
,
886 piAdvance
, NULL
, pGoffset
);
887 ok (hr
== 0, "ScriptTextOut should return 0 not (%08x)\n", hr
);
889 /* Test Rect Rgn is acceptable */
894 hr
= ScriptTextOut(hdc
, &psc
, 0, 0, 0, &rect
, &pItem
[0].a
, NULL
, 0, pwOutGlyphs1
, pcGlyphs
,
895 piAdvance
, NULL
, pGoffset
);
896 ok (hr
== 0, "ScriptTextOut should return 0 not (%08x)\n", hr
);
899 hr
= ScriptCPtoX(iCP
, fTrailing
, cChars
, pcGlyphs
, (const WORD
*) &pwLogClust
,
900 (const SCRIPT_VISATTR
*) &psva
, (const int *)&piAdvance
, &pItem
[0].a
, &piX
);
901 ok(hr
== S_OK
, "ScriptCPtoX Stub should return S_OK not %08x\n", hr
);
903 psla
= (SCRIPT_LOGATTR
*)&sla
;
904 hr
= ScriptBreak(TestItem1
, cChars
, &pItem
[0].a
, psla
);
905 ok(hr
== S_OK
, "ScriptBreak Stub should return S_OK not %08x\n", hr
);
907 /* Clean up and go */
908 ScriptFreeCache(&psc
);
909 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
914 static void test_ScriptTextOut2(HDC hdc
)
916 /* Intent is to validate that the HDC passed into ScriptTextOut is
917 * used instead of the (possibly) invalid cached one
924 SCRIPT_ITEM pItem
[255];
926 WCHAR TestItem1
[] = {'T', 'e', 's', 't', 'a', 0};
931 unsigned short pwOutGlyphs1
[256];
932 WORD pwLogClust
[256];
933 SCRIPT_VISATTR psva
[256];
936 GOFFSET pGoffset
[256];
939 /* Create an extra DC that will be used until the ScriptTextOut */
940 hdc1
= CreateCompatibleDC(hdc
);
941 ok (hdc1
!= 0, "CreateCompatibleDC failed to create a DC\n");
942 hdc2
= CreateCompatibleDC(hdc
);
943 ok (hdc2
!= 0, "CreateCompatibleDC failed to create a DC\n");
945 /* This is a valid test that will cause parsing to take place */
948 hr
= ScriptItemize(TestItem1
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
949 ok (hr
== 0, "ScriptItemize should return 0, returned %08x\n", hr
);
950 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
952 ok (pcItems
> 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
954 ok (pItem
[0].iCharPos
== 0 && pItem
[1].iCharPos
== cInChars
,
955 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
956 pItem
[0].iCharPos
, cInChars
, pItem
[1].iCharPos
);
958 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
959 * ie. ScriptItemize has succeeded and that pItem has been set */
963 psc
= NULL
; /* must be null on first call */
965 cMaxGlyphs
= cInChars
;
967 hr
= ScriptShape(hdc2
, &psc
, TestItem1
, cChars
,
968 cMaxGlyphs
, &pItem
[0].a
,
969 pwOutGlyphs1
, pwLogClust
, psva
, &pcGlyphs
);
970 ok (hr
== 0, "ScriptShape should return 0 not (%08x)\n", hr
);
971 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
972 ok (pcGlyphs
== cChars
, "Chars in (%d) should equal Glyphs out (%d)\n", cChars
, pcGlyphs
);
974 /* Note hdc is needed as glyph info is not yet in psc */
975 hr
= ScriptPlace(hdc2
, &psc
, pwOutGlyphs1
, pcGlyphs
, psva
, &pItem
[0].a
, piAdvance
,
977 ok (hr
== 0, "Should return 0 not (%08x)\n", hr
);
979 /* key part!!! cached dc is being deleted */
981 ok(hr
== 1, "DeleteDC should return 1 not %08x\n", hr
);
983 /* At this point the cached hdc (hdc2) has been destroyed,
984 * however, we are passing in a *real* hdc (the original hdc).
985 * The text should be written to that DC
987 hr
= ScriptTextOut(hdc1
, &psc
, 0, 0, 0, NULL
, &pItem
[0].a
, NULL
, 0, pwOutGlyphs1
, pcGlyphs
,
988 piAdvance
, NULL
, pGoffset
);
989 ok (hr
== 0, "ScriptTextOut should return 0 not (%08x)\n", hr
);
990 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
994 /* Clean up and go */
995 ScriptFreeCache(&psc
);
996 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
1001 static void test_ScriptTextOut3(HDC hdc
)
1007 SCRIPT_ITEM pItem
[255];
1009 WCHAR TestItem1
[] = {' ','\r', 0};
1014 unsigned short pwOutGlyphs1
[256];
1015 WORD pwLogClust
[256];
1016 SCRIPT_VISATTR psva
[256];
1019 GOFFSET pGoffset
[256];
1023 /* This is to ensure that non exisiting glyphs are translated into a valid glyph number */
1026 hr
= ScriptItemize(TestItem1
, cInChars
, cMaxItems
, NULL
, NULL
, pItem
, &pcItems
);
1027 ok (hr
== 0, "ScriptItemize should return 0, returned %08x\n", hr
);
1028 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
1030 ok (pcItems
> 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
1032 ok (pItem
[0].iCharPos
== 0 && pItem
[2].iCharPos
== cInChars
,
1033 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
1034 pItem
[0].iCharPos
, cInChars
, pItem
[2].iCharPos
);
1036 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
1037 * ie. ScriptItemize has succeeded and that pItem has been set */
1041 psc
= NULL
; /* must be null on first call */
1043 cMaxGlyphs
= cInChars
;
1045 hr
= ScriptShape(hdc
, &psc
, TestItem1
, cChars
,
1046 cMaxGlyphs
, &pItem
[0].a
,
1047 pwOutGlyphs1
, pwLogClust
, psva
, &pcGlyphs
);
1048 ok (hr
== 0, "ScriptShape should return 0 not (%08x)\n", hr
);
1049 ok (psc
!= NULL
, "psc should not be null and have SCRIPT_CACHE buffer address\n");
1050 ok (pcGlyphs
== cChars
, "Chars in (%d) should equal Glyphs out (%d)\n", cChars
, pcGlyphs
);
1052 /* Note hdc is needed as glyph info is not yet in psc */
1053 hr
= ScriptPlace(hdc
, &psc
, pwOutGlyphs1
, pcGlyphs
, psva
, &pItem
[0].a
, piAdvance
,
1055 ok (hr
== 0, "Should return 0 not (%08x)\n", hr
);
1057 /* Test Rect Rgn is acceptable */
1062 hr
= ScriptTextOut(hdc
, &psc
, 0, 0, 0, &rect
, &pItem
[0].a
, NULL
, 0, pwOutGlyphs1
, pcGlyphs
,
1063 piAdvance
, NULL
, pGoffset
);
1064 ok (hr
== 0, "ScriptTextOut should return 0 not (%08x)\n", hr
);
1067 /* Clean up and go */
1068 ScriptFreeCache(&psc
);
1069 ok( psc
== NULL
, "Expected psc to be NULL, got %p\n", psc
);
1073 static void test_ScriptXtoX(void)
1074 /****************************************************************************************
1075 * This routine tests the ScriptXtoCP and ScriptCPtoX functions using static variables *
1076 ****************************************************************************************/
1078 static const WCHAR test
[] = {'t', 'e', 's', 't',0};
1079 SCRIPT_ITEM items
[2];
1083 WORD pwLogClust
[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1084 SCRIPT_VISATTR psva
[10];
1085 int piAdvance
[10] = {200, 190, 210, 180, 170, 204, 189, 195, 212, 203};
1091 hr
= ScriptItemize(test
, lstrlenW(test
), sizeof(items
)/sizeof(items
[0]), NULL
, NULL
, items
, NULL
);
1092 ok(!hr
, "ScriptItemize should return S_OK not %08x\n", hr
);
1097 hr
= ScriptXtoCP(iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piCP
, &piTrailing
);
1098 ok(hr
== S_OK
, "ScriptXtoCP should return S_OK not %08x\n", hr
);
1100 ok(piCP
== -1, "Negative iX should return piCP=-1 not %d\n", piCP
);
1102 ok(piCP
== 10, "Negative iX should return piCP=10 not %d\n", piCP
);
1107 hr
= ScriptXtoCP(iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piCP
, &piTrailing
);
1108 ok(hr
== S_OK
, "ScriptXtoCP should return S_OK not %08x\n", hr
);
1109 if (piTrailing
) /* win2k3 */
1110 ok(piCP
== -1, "Negative iX should return piCP=-1 not %d\n", piCP
);
1112 ok(piCP
== 10, "Negative iX should return piCP=10 not %d\n", piCP
);
1117 hr
= ScriptXtoCP(iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piCP
, &piTrailing
);
1118 ok(hr
== S_OK
, "ScriptXtoCP should return S_OK not %08x\n", hr
);
1120 piCP
== -1, /* win2k3 */
1121 "iX=%d should return piCP=3 or piCP=-1 not %d\n", iX
, piCP
);
1122 ok(piTrailing
== 1, "iX=%d should return piTrailing=1 not %d\n", iX
, piTrailing
);
1127 hr
= ScriptXtoCP(iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piCP
, &piTrailing
);
1128 ok(hr
== S_OK
, "ScriptXtoCP should return S_OK not %08x\n", hr
);
1130 piCP
== -1, /* win2k3 */
1131 "iX=%d should return piCP=3 or piCP=-1 not %d\n", iX
, piCP
);
1132 ok(piTrailing
== 1, "iX=%d should return piTrailing=1 not %d\n", iX
, piTrailing
);
1137 hr
= ScriptXtoCP(iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piCP
, &piTrailing
);
1138 ok(hr
== S_OK
, "ScriptXtoCP should return S_OK not %08x\n", hr
);
1140 piCP
== -1, /* win2k3 */
1141 "iX=%d should return piCP=4 or piCP=-1 not %d\n", iX
, piCP
);
1146 hr
= ScriptXtoCP(iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piCP
, &piTrailing
);
1147 ok(hr
== S_OK
, "ScriptXtoCP should return S_OK not %08x\n", hr
);
1149 piCP
== 10, /* win2k3 */
1150 "iX=%d should return piCP=0 piCP=10 not %d\n", iX
, piCP
);
1155 hr
= ScriptXtoCP(iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piCP
, &piTrailing
);
1156 ok(hr
== S_OK
, "ScriptXtoCP should return S_OK not %08x\n", hr
);
1157 ok(piCP
== 0, "iX=%d should return piCP=0 not %d\n", iX
, piCP
);
1162 hr
= ScriptXtoCP(iX
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piCP
, &piTrailing
);
1163 ok(hr
== S_OK
, "ScriptXtoCP should return S_OK not %08x\n", hr
);
1165 piCP
== 0, /* win2k3 */
1166 "iX=%d should return piCP=1 or piCP=0 not %d\n", iX
, piCP
);
1172 hr
= ScriptCPtoX(iCP
, fTrailing
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piX
);
1173 ok(hr
== S_OK
, "ScriptCPtoX should return S_OK not %08x\n", hr
);
1175 piX
== 100, /* win2k3 */
1176 "iCP=%d should return piX=976 or piX=100 not %d\n", iCP
, piX
);
1182 hr
= ScriptCPtoX(iCP
, fTrailing
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piX
);
1183 ok(hr
== S_OK
, "ScriptCPtoX should return S_OK not %08x\n", hr
);
1185 piX
== 80, /* win2k3 */
1186 "iCP=%d should return piX=1171 or piX=80 not %d\n", iCP
, piX
);
1192 hr
= ScriptCPtoX(iCP
, fTrailing
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piX
);
1193 ok(hr
== S_OK
, "ScriptCPtoX should return S_OK not %08x\n", hr
);
1195 piX
== 80, /* win2k3 */
1196 "iCP=%d should return piX=1171 or piX=80 not %d\n", iCP
, piX
);
1202 hr
= ScriptCPtoX(iCP
, fTrailing
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piX
);
1203 ok(hr
== S_OK
, "ScriptCPtoX should return S_OK not %08x\n", hr
);
1205 piX
== 0, /* win2k3 */
1206 "iCP=%d should return piX=1953 or piX=0 not %d\n", iCP
, piX
);
1212 hr
= ScriptCPtoX(iCP
, fTrailing
, cChars
, cGlyphs
, pwLogClust
, psva
, piAdvance
, &items
[0].a
, &piX
);
1213 ok(hr
== S_OK
, "ScriptCPtoX should return S_OK not %08x\n", hr
);
1215 piX
== 0, /* win2k3 */
1216 "iCP=%d should return piX=1953 or piX=0 not %d\n", iCP
, piX
);
1219 static void test_ScriptString(HDC hdc
)
1221 /*******************************************************************************************
1223 * This set of tests are for the string functions of uniscribe. The ScriptStringAnalyse
1224 * function allocates memory pointed to by the SCRIPT_STRING_ANALYSIS ssa pointer. This
1225 * memory if freed by ScriptStringFree. There needs to be a valid hdc for this as
1226 * ScriptStringAnalyse calls ScriptSItemize, ScriptShape and ScriptPlace which require it.
1231 WCHAR teststr
[] = {'T','e','s','t','1',' ','a','2','b','3', '\0'};
1232 int len
= (sizeof(teststr
) / sizeof(WCHAR
)) - 1;
1233 int Glyphs
= len
* 2 + 16;
1235 DWORD Flags
= SSA_GLYPHS
;
1237 SCRIPT_CONTROL Control
;
1239 const int Dx
[5] = {10, 10, 10, 10, 10};
1240 SCRIPT_TABDEF Tabdef
;
1241 const BYTE InClass
= 0;
1242 SCRIPT_STRING_ANALYSIS ssa
= NULL
;
1247 const RECT rc
= {0, 50, 100, 100};
1250 BOOL Disabled
= FALSE
;
1251 const int *clip_len
;
1256 Charset
= -1; /* this flag indicates unicode input */
1257 /* Test without hdc to get E_PENDING */
1258 hr
= ScriptStringAnalyse( NULL
, teststr
, len
, Glyphs
, Charset
, Flags
,
1259 ReqWidth
, &Control
, &State
, Dx
, &Tabdef
,
1261 ok(hr
== E_PENDING
, "ScriptStringAnalyse Stub should return E_PENDING not %08x\n", hr
);
1263 /* test with hdc, this should be a valid test */
1264 hr
= ScriptStringAnalyse( hdc
, teststr
, len
, Glyphs
, Charset
, Flags
,
1265 ReqWidth
, &Control
, &State
, Dx
, &Tabdef
,
1267 ok(hr
== S_OK
, "ScriptStringAnalyse should return S_OK not %08x\n", hr
);
1268 ScriptStringFree(&ssa
);
1270 /* test makes sure that a call with a valid pssa still works */
1271 hr
= ScriptStringAnalyse( hdc
, teststr
, len
, Glyphs
, Charset
, Flags
,
1272 ReqWidth
, &Control
, &State
, Dx
, &Tabdef
,
1274 ok(hr
== S_OK
, "ScriptStringAnalyse should return S_OK not %08x\n", hr
);
1275 ok(ssa
!= NULL
, "ScriptStringAnalyse pssa should not be NULL\n");
1279 hr
= ScriptStringOut(ssa
, X
, Y
, Options
, &rc
, MinSel
, MaxSel
, Disabled
);
1280 ok(hr
== S_OK
, "ScriptStringOut should return S_OK not %08x\n", hr
);
1283 clip_len
= ScriptString_pcOutChars(ssa
);
1284 ok(*clip_len
== len
, "ScriptString_pcOutChars failed, got %d, expected %d\n", *clip_len
, len
);
1286 order
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, *clip_len
* sizeof(UINT
));
1287 hr
= ScriptStringGetOrder(ssa
, order
);
1288 ok(hr
== S_OK
, "ScriptStringGetOrder failed, got %08x, expected S_OK\n", hr
);
1290 for (i
= 0; i
< *clip_len
; i
++) ok(order
[i
] == i
, "%d: got %d expected %d\n", i
, order
[i
], i
);
1291 HeapFree(GetProcessHeap(), 0, order
);
1293 hr
= ScriptStringFree(&ssa
);
1294 ok(hr
== S_OK
, "ScriptStringFree should return S_OK not %08x\n", hr
);
1297 static void test_ScriptStringXtoCP_CPtoX(HDC hdc
)
1299 /*****************************************************************************************
1301 * This test is for the ScriptStringXtoCP and ScriptStringXtoCP functions. Due to the
1302 * nature of the fonts between Windows and Wine, the test is implemented by generating
1303 * values using one one function then checking the output of the second. In this way
1304 * the validity of the functions is established using Windows as a base and confirming
1305 * similar behaviour in wine.
1309 WCHAR teststr1
[] = {'T', 'e', 's', 't', 'e', 'a', 'b', ' ', 'a', '\0'};
1310 void *String
= (WCHAR
*) &teststr1
; /* ScriptStringAnalysis needs void */
1311 int String_len
= (sizeof(teststr1
)/sizeof(WCHAR
))-1;
1312 int Glyphs
= String_len
* 2 + 16; /* size of buffer as recommended */
1313 int Charset
= -1; /* unicode */
1314 DWORD Flags
= SSA_GLYPHS
;
1316 SCRIPT_CONTROL Control
;
1318 SCRIPT_TABDEF Tabdef
;
1319 const BYTE InClass
= 0;
1320 SCRIPT_STRING_ANALYSIS ssa
= NULL
;
1322 int Ch
; /* Character position in string */
1324 int Cp
; /* Character position in string */
1328 /* Test with hdc, this should be a valid test
1329 * Here we generate an SCRIPT_STRING_ANALYSIS that will be used as input to the
1330 * following character positions to X and X to character position functions.
1332 memset(&Control
, 0, sizeof(SCRIPT_CONTROL
));
1333 memset(&State
, 0, sizeof(SCRIPT_STATE
));
1334 memset(&Tabdef
, 0, sizeof(SCRIPT_TABDEF
));
1336 hr
= ScriptStringAnalyse( hdc
, String
, String_len
, Glyphs
, Charset
, Flags
,
1337 ReqWidth
, &Control
, &State
, NULL
, &Tabdef
,
1340 hr
== E_INVALIDARG
, /* NT */
1341 "ScriptStringAnalyse should return S_OK or E_INVALIDARG not %08x\n", hr
);
1345 ok(ssa
!= NULL
, "ScriptStringAnalyse ssa should not be NULL\n");
1348 * Loop to generate character positions to provide starting positions for the
1349 * ScriptStringCPtoX and ScriptStringXtoCP functions
1351 for (Cp
= 0; Cp
< String_len
; Cp
++)
1353 /* The fTrailing flag is used to indicate whether the X being returned is at
1354 * the beginning or the end of the character. What happens here is that if
1355 * fTrailing indicates the end of the character, ie. FALSE, then ScriptStringXtoCP
1356 * returns the beginning of the next character and iTrailing is FALSE. So for this
1357 * loop iTrailing will be FALSE in both cases.
1360 hr
= ScriptStringCPtoX(ssa
, Cp
, fTrailing
, &X
);
1361 ok(hr
== S_OK
, "ScriptStringCPtoX should return S_OK not %08x\n", hr
);
1362 hr
= ScriptStringXtoCP(ssa
, X
, &Ch
, &iTrailing
);
1363 ok(hr
== S_OK
, "ScriptStringXtoCP should return S_OK not %08x\n", hr
);
1364 ok(Cp
== Ch
, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp
, Ch
, X
);
1365 ok(iTrailing
== FALSE
, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
1368 hr
= ScriptStringCPtoX(ssa
, Cp
, fTrailing
, &X
);
1369 ok(hr
== S_OK
, "ScriptStringCPtoX should return S_OK not %08x\n", hr
);
1370 hr
= ScriptStringXtoCP(ssa
, X
, &Ch
, &iTrailing
);
1371 ok(hr
== S_OK
, "ScriptStringXtoCP should return S_OK not %08x\n", hr
);
1374 * Check that character position returned by ScriptStringXtoCP in Ch matches the
1375 * one input to ScriptStringCPtoX. This means that the Cp to X position and back
1378 ok(Cp
+ 1 == Ch
, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp
+ 1, Ch
, X
);
1379 ok(iTrailing
== FALSE
, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
1383 * This test is to check that if the X position is just inside the trailing edge of the
1384 * character then iTrailing will indicate the trailing edge, ie. TRUE
1388 hr
= ScriptStringCPtoX(ssa
, Cp
, fTrailing
, &X
);
1389 ok(hr
== S_OK
, "ScriptStringCPtoX should return S_OK not %08x\n", hr
);
1390 X
--; /* put X just inside the trailing edge */
1391 hr
= ScriptStringXtoCP(ssa
, X
, &Ch
, &iTrailing
);
1392 ok(hr
== S_OK
, "ScriptStringXtoCP should return S_OK not %08x\n", hr
);
1393 ok(Cp
== Ch
, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp
, Ch
, X
);
1394 ok(iTrailing
== TRUE
, "ScriptStringXtoCP should return iTrailing = 1 not %d for X = %d\n",
1398 * This test is to check that if the X position is just outside the trailing edge of the
1399 * character then iTrailing will indicate the leading edge, ie. FALSE, and Ch will indicate
1400 * the next character, ie. Cp + 1
1404 hr
= ScriptStringCPtoX(ssa
, Cp
, fTrailing
, &X
);
1405 ok(hr
== S_OK
, "ScriptStringCPtoX should return S_OK not %08x\n", hr
);
1406 X
++; /* put X just outside the trailing edge */
1407 hr
= ScriptStringXtoCP(ssa
, X
, &Ch
, &iTrailing
);
1408 ok(hr
== S_OK
, "ScriptStringXtoCP should return S_OK not %08x\n", hr
);
1409 ok(Cp
+ 1 == Ch
, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp
+ 1, Ch
, X
);
1410 ok(iTrailing
== FALSE
, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
1414 * This test is to check that if the X position is just outside the leading edge of the
1415 * character then iTrailing will indicate the trailing edge, ie. TRUE, and Ch will indicate
1416 * the next character down , ie. Cp - 1
1420 hr
= ScriptStringCPtoX(ssa
, Cp
, fTrailing
, &X
);
1421 ok(hr
== S_OK
, "ScriptStringCPtoX should return S_OK not %08x\n", hr
);
1422 X
--; /* put X just outside the leading edge */
1423 hr
= ScriptStringXtoCP(ssa
, X
, &Ch
, &iTrailing
);
1424 ok(hr
== S_OK
, "ScriptStringXtoCP should return S_OK not %08x\n", hr
);
1425 ok(Cp
- 1 == Ch
, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp
- 1, Ch
, X
);
1426 ok(iTrailing
== TRUE
, "ScriptStringXtoCP should return iTrailing = 1 not %d for X = %d\n",
1430 * Cleanup the SSA for the next round of tests
1432 hr
= ScriptStringFree(&ssa
);
1433 ok(hr
== S_OK
, "ScriptStringFree should return S_OK not %08x\n", hr
);
1436 * Test to see that exceeding the number of chars returns E_INVALIDARG. First
1437 * generate an SSA for the subsequent tests.
1439 hr
= ScriptStringAnalyse( hdc
, String
, String_len
, Glyphs
, Charset
, Flags
,
1440 ReqWidth
, &Control
, &State
, NULL
, &Tabdef
,
1442 ok(hr
== S_OK
, "ScriptStringAnalyse should return S_OK not %08x\n", hr
);
1445 * When ScriptStringCPtoX is called with a character position Cp that exceeds the
1446 * string length, return E_INVALIDARG. This also invalidates the ssa so a
1447 * ScriptStringFree should also fail.
1450 Cp
= String_len
+ 1;
1451 hr
= ScriptStringCPtoX(ssa
, Cp
, fTrailing
, &X
);
1452 ok(hr
== E_INVALIDARG
, "ScriptStringCPtoX should return E_INVALIDARG not %08x\n", hr
);
1454 ScriptStringFree(&ssa
);
1458 static void test_ScriptCacheGetHeight(HDC hdc
)
1461 SCRIPT_CACHE sc
= NULL
;
1464 hr
= ScriptCacheGetHeight(NULL
, NULL
, NULL
);
1465 ok(hr
== E_INVALIDARG
, "expected E_INVALIDARG, got 0x%08x\n", hr
);
1467 hr
= ScriptCacheGetHeight(NULL
, &sc
, NULL
);
1468 ok(hr
== E_INVALIDARG
, "expected E_INVALIDARG, got 0x%08x\n", hr
);
1470 hr
= ScriptCacheGetHeight(NULL
, &sc
, &height
);
1471 ok(hr
== E_PENDING
, "expected E_PENDING, got 0x%08x\n", hr
);
1475 hr
= ScriptCacheGetHeight(hdc
, &sc
, &height
);
1476 ok(hr
== S_OK
, "expected S_OK, got 0x%08x\n", hr
);
1477 ok(height
> 0, "expected height > 0\n");
1479 ScriptFreeCache(&sc
);
1482 static void test_ScriptGetGlyphABCWidth(HDC hdc
)
1485 SCRIPT_CACHE sc
= NULL
;
1488 hr
= ScriptGetGlyphABCWidth(NULL
, NULL
, 'a', NULL
);
1489 ok(hr
== E_INVALIDARG
, "expected E_INVALIDARG, got 0x%08x\n", hr
);
1491 hr
= ScriptGetGlyphABCWidth(NULL
, &sc
, 'a', NULL
);
1492 ok(broken(hr
== E_PENDING
) ||
1493 hr
== E_INVALIDARG
, /* WIN7 */
1494 "expected E_INVALIDARG, got 0x%08x\n", hr
);
1496 hr
= ScriptGetGlyphABCWidth(NULL
, &sc
, 'a', &abc
);
1497 ok(hr
== E_PENDING
, "expected E_PENDING, got 0x%08x\n", hr
);
1499 if (0) { /* crashes on WinXP */
1500 hr
= ScriptGetGlyphABCWidth(hdc
, &sc
, 'a', NULL
);
1501 ok(hr
== E_INVALIDARG
, "expected E_INVALIDARG, got 0x%08x\n", hr
);
1504 hr
= ScriptGetGlyphABCWidth(hdc
, &sc
, 'a', &abc
);
1505 ok(hr
== S_OK
, "expected S_OK, got 0x%08x\n", hr
);
1507 ScriptFreeCache(&sc
);
1510 static void test_ScriptLayout(void)
1513 static const BYTE levels
[][10] =
1515 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
1516 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
1517 { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
1518 { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
1520 { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1},
1521 { 1, 1, 1, 2, 2, 2, 1, 1, 1, 1 },
1522 { 2, 2, 2, 1, 1, 1, 2, 2, 2, 2 },
1523 { 0, 0, 1, 1, 2, 2, 1, 1, 0, 0 },
1524 { 1, 1, 2, 2, 3, 3, 2, 2, 1, 1 },
1526 { 0, 0, 1, 1, 2, 2, 1, 1, 0, 1 },
1527 { 1, 0, 1, 2, 2, 1, 2, 1, 0, 1 },
1529 static const int expect_l2v
[][10] =
1531 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
1532 { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
1533 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
1534 { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
1536 { 0, 1, 2, 3, 4, 9, 8 ,7 ,6, 5},
1537 /**/ { 9, 8, 7, 4, 5, 6, 3 ,2 ,1, 0},
1538 /**/ { 7, 8, 9, 6, 5, 4, 0 ,1 ,2, 3},
1539 { 0, 1, 7, 6, 4, 5, 3 ,2 ,8, 9},
1540 { 9, 8, 2, 3, 5, 4, 6 ,7 ,1, 0},
1542 { 0, 1, 7, 6, 4, 5, 3 ,2 ,8, 9},
1543 /**/ { 0, 1, 7, 5, 6, 4, 3 ,2 ,8, 9},
1545 static const int expect_v2l
[][10] =
1547 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
1548 { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
1549 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
1550 { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
1552 { 0, 1, 2, 3, 4, 9, 8 ,7 ,6, 5},
1553 { 9, 8, 7, 6, 3, 4, 5 ,2 ,1, 0},
1554 { 6, 7, 8, 9, 5, 4, 3 ,0 ,1, 2},
1555 { 0, 1, 7, 6, 4, 5, 3 ,2 ,8, 9},
1556 { 9, 8, 2, 3, 5, 4, 6 ,7 ,1, 0},
1558 { 0, 1, 7, 6, 4, 5, 3 ,2 ,8, 9},
1559 { 0, 1, 7, 6, 5, 3, 4 ,2 ,8, 9},
1562 int i
, j
, vistolog
[sizeof(levels
[0])], logtovis
[sizeof(levels
[0])];
1564 hr
= ScriptLayout(sizeof(levels
[0]), NULL
, vistolog
, logtovis
);
1565 ok(hr
== E_INVALIDARG
, "expected E_INVALIDARG, got 0x%08x\n", hr
);
1567 hr
= ScriptLayout(sizeof(levels
[0]), levels
[0], NULL
, NULL
);
1568 ok(hr
== E_INVALIDARG
, "expected E_INVALIDARG, got 0x%08x\n", hr
);
1570 for (i
= 0; i
< sizeof(levels
)/sizeof(levels
[0]); i
++)
1572 hr
= ScriptLayout(sizeof(levels
[0]), levels
[i
], vistolog
, logtovis
);
1573 ok(hr
== S_OK
, "expected S_OK, got 0x%08x\n", hr
);
1575 for (j
= 0; j
< sizeof(levels
[i
]); j
++)
1577 ok(expect_v2l
[i
][j
] == vistolog
[j
],
1578 "failure: levels[%d][%d] = %d, vistolog[%d] = %d\n",
1579 i
, j
, levels
[i
][j
], j
, vistolog
[j
] );
1582 for (j
= 0; j
< sizeof(levels
[i
]); j
++)
1584 ok(expect_l2v
[i
][j
] == logtovis
[j
],
1585 "failure: levels[%d][%d] = %d, logtovis[%d] = %d\n",
1586 i
, j
, levels
[i
][j
], j
, logtovis
[j
] );
1591 static BOOL CALLBACK
enum_proc(LGRPID group
, LCID lcid
, LPSTR locale
, LONG_PTR lparam
)
1594 SCRIPT_DIGITSUBSTITUTE sds
;
1599 if (!IsValidLocale(lcid
, LCID_INSTALLED
)) return TRUE
;
1601 memset(&sds
, 0, sizeof(sds
));
1602 memset(&sc
, 0, sizeof(sc
));
1603 memset(&ss
, 0, sizeof(ss
));
1605 lcid_old
= GetThreadLocale();
1606 if (!SetThreadLocale(lcid
)) return TRUE
;
1608 hr
= ScriptRecordDigitSubstitution(lcid
, &sds
);
1609 ok(hr
== S_OK
, "ScriptRecordDigitSubstitution failed: 0x%08x\n", hr
);
1611 hr
= ScriptApplyDigitSubstitution(&sds
, &sc
, &ss
);
1612 ok(hr
== S_OK
, "ScriptApplyDigitSubstitution failed: 0x%08x\n", hr
);
1614 SetThreadLocale(lcid_old
);
1618 static void test_digit_substitution(void)
1622 static const LGRPID groups
[] =
1624 LGRPID_WESTERN_EUROPE
,
1625 LGRPID_CENTRAL_EUROPE
,
1632 LGRPID_TRADITIONAL_CHINESE
,
1633 LGRPID_SIMPLIFIED_CHINESE
,
1643 static BOOL (WINAPI
* pEnumLanguageGroupLocalesA
)(LANGGROUPLOCALE_ENUMPROCA
,LGRPID
,DWORD
,LONG_PTR
);
1645 hKernel32
= GetModuleHandleA("kernel32.dll");
1646 pEnumLanguageGroupLocalesA
= (void*)GetProcAddress(hKernel32
, "EnumLanguageGroupLocalesA");
1648 if (!pEnumLanguageGroupLocalesA
)
1650 win_skip("EnumLanguageGroupLocalesA not available on this platform\n");
1654 for (i
= 0; i
< sizeof(groups
)/sizeof(groups
[0]); i
++)
1656 ret
= pEnumLanguageGroupLocalesA(enum_proc
, groups
[i
], 0, 0);
1657 if (!ret
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
)
1659 win_skip("EnumLanguageGroupLocalesA not implemented on this platform\n");
1663 ok(ret
, "EnumLanguageGroupLocalesA failed unexpectedly: %u\n", GetLastError());
1667 static void test_ScriptGetProperties(void)
1669 const SCRIPT_PROPERTIES
**props
;
1673 hr
= ScriptGetProperties(NULL
, NULL
);
1674 ok(hr
== E_INVALIDARG
, "ScriptGetProperties succeeded\n");
1676 hr
= ScriptGetProperties(NULL
, &num
);
1677 ok(hr
== S_OK
, "ScriptGetProperties failed: 0x%08x\n", hr
);
1679 hr
= ScriptGetProperties(&props
, NULL
);
1680 ok(hr
== S_OK
, "ScriptGetProperties failed: 0x%08x\n", hr
);
1682 hr
= ScriptGetProperties(&props
, &num
);
1683 ok(hr
== S_OK
, "ScriptGetProperties failed: 0x%08x\n", hr
);
1686 static void test_ScriptBreak(void)
1688 static const WCHAR test
[] = {' ','\r','\n',0};
1689 SCRIPT_ITEM items
[4];
1693 hr
= ScriptItemize(test
, 3, 4, NULL
, NULL
, items
, NULL
);
1694 ok(!hr
, "ScriptItemize should return S_OK not %08x\n", hr
);
1696 memset(&la
, 0, sizeof(la
));
1697 hr
= ScriptBreak(test
, 1, &items
[0].a
, &la
);
1698 ok(!hr
, "ScriptBreak should return S_OK not %08x\n", hr
);
1700 ok(!la
.fSoftBreak
, "fSoftBreak set\n");
1701 ok(la
.fWhiteSpace
, "fWhiteSpace not set\n");
1702 ok(la
.fCharStop
, "fCharStop not set\n");
1703 ok(!la
.fWordStop
, "fWordStop set\n");
1704 ok(!la
.fInvalid
, "fInvalid set\n");
1705 ok(!la
.fReserved
, "fReserved set\n");
1707 memset(&la
, 0, sizeof(la
));
1708 hr
= ScriptBreak(test
+ 1, 1, &items
[1].a
, &la
);
1709 ok(!hr
, "ScriptBreak should return S_OK not %08x\n", hr
);
1711 ok(!la
.fSoftBreak
, "fSoftBreak set\n");
1712 ok(!la
.fWhiteSpace
, "fWhiteSpace set\n");
1713 ok(la
.fCharStop
, "fCharStop not set\n");
1714 ok(!la
.fWordStop
, "fWordStop set\n");
1715 ok(!la
.fInvalid
, "fInvalid set\n");
1716 ok(!la
.fReserved
, "fReserved set\n");
1718 memset(&la
, 0, sizeof(la
));
1719 hr
= ScriptBreak(test
+ 2, 1, &items
[2].a
, &la
);
1720 ok(!hr
, "ScriptBreak should return S_OK not %08x\n", hr
);
1722 ok(!la
.fSoftBreak
, "fSoftBreak set\n");
1723 ok(!la
.fWhiteSpace
, "fWhiteSpace set\n");
1724 ok(la
.fCharStop
, "fCharStop not set\n");
1725 ok(!la
.fWordStop
, "fWordStop set\n");
1726 ok(!la
.fInvalid
, "fInvalid set\n");
1727 ok(!la
.fReserved
, "fReserved set\n");
1730 static void test_newlines(void)
1732 static const WCHAR test1
[] = {'t','e','x','t','\r','t','e','x','t',0};
1733 static const WCHAR test2
[] = {'t','e','x','t','\n','t','e','x','t',0};
1734 static const WCHAR test3
[] = {'t','e','x','t','\r','\n','t','e','x','t',0};
1735 static const WCHAR test4
[] = {'t','e','x','t','\n','\r','t','e','x','t',0};
1736 static const WCHAR test5
[] = {'1','2','3','4','\n','\r','1','2','3','4',0};
1737 SCRIPT_ITEM items
[5];
1742 hr
= ScriptItemize(test1
, lstrlenW(test1
), 5, NULL
, NULL
, items
, &count
);
1743 ok(hr
== S_OK
, "ScriptItemize failed: 0x%08x\n", hr
);
1744 ok(count
== 3, "got %d expected 3\n", count
);
1747 hr
= ScriptItemize(test2
, lstrlenW(test2
), 5, NULL
, NULL
, items
, &count
);
1748 ok(hr
== S_OK
, "ScriptItemize failed: 0x%08x\n", hr
);
1749 ok(count
== 3, "got %d expected 3\n", count
);
1752 hr
= ScriptItemize(test3
, lstrlenW(test3
), 5, NULL
, NULL
, items
, &count
);
1753 ok(hr
== S_OK
, "ScriptItemize failed: 0x%08x\n", hr
);
1754 ok(count
== 4, "got %d expected 4\n", count
);
1757 hr
= ScriptItemize(test4
, lstrlenW(test4
), 5, NULL
, NULL
, items
, &count
);
1758 ok(hr
== S_OK
, "ScriptItemize failed: 0x%08x\n", hr
);
1759 ok(count
== 4, "got %d expected 4\n", count
);
1762 hr
= ScriptItemize(test5
, lstrlenW(test5
), 5, NULL
, NULL
, items
, &count
);
1763 ok(hr
== S_OK
, "ScriptItemize failed: 0x%08x\n", hr
);
1764 ok(count
== 4, "got %d expected 4\n", count
);
1774 unsigned short pwOutGlyphs
[256];
1776 /* We need a valid HDC to drive a lot of Script functions which requires the following *
1777 * to set up for the tests. */
1778 hwnd
= CreateWindowExA(0, "static", "", WS_POPUP
, 0,0,100,100,
1781 ShowWindow(hwnd
, SW_SHOW
);
1784 hdc
= GetDC(hwnd
); /* We now have a hdc */
1785 ok( hdc
!= NULL
, "HDC failed to be created %p\n", hdc
);
1787 memset(&lf
, 0, sizeof(LOGFONTA
));
1788 lstrcpyA(lf
.lfFaceName
, "Tahoma");
1793 hfont
= SelectObject(hdc
, CreateFontIndirectA(&lf
));
1794 ok(hfont
!= NULL
, "SelectObject failed: %p\n", hfont
);
1796 test_ScriptItemize();
1797 test_ScriptItemIzeShapePlace(hdc
,pwOutGlyphs
);
1798 test_ScriptGetCMap(hdc
, pwOutGlyphs
);
1799 test_ScriptCacheGetHeight(hdc
);
1800 test_ScriptGetGlyphABCWidth(hdc
);
1801 test_ScriptShape(hdc
);
1802 test_ScriptPlace(hdc
);
1804 test_ScriptGetFontProperties(hdc
);
1805 test_ScriptTextOut(hdc
);
1806 test_ScriptTextOut2(hdc
);
1807 test_ScriptTextOut3(hdc
);
1809 test_ScriptString(hdc
);
1810 test_ScriptStringXtoCP_CPtoX(hdc
);
1812 test_ScriptLayout();
1813 test_digit_substitution();
1814 test_ScriptGetProperties();
1818 ReleaseDC(hwnd
, hdc
);
1819 DestroyWindow(hwnd
);