?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pop fafc973c8c92ea6fa823adc8f5a7f591f01396fd
[wine/hacks.git] / dlls / usp10 / tests / usp10.c
blobefc0569d3be41da7e929d4508b1ff86c4cd67a39
1 /*
2 * Tests for usp10 dll
3 *
4 * Copyright 2006 Jeff Latimer
5 * Copyright 2006 Hans Leidekker
6 * Copyright 2010 CodeWeavers, Aric Stewart
7 *
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.
12 *
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.
17 *
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
21 *
22 * Notes:
23 * Uniscribe allows for processing of complex scripts such as joining
24 * and filtering characters and bi-directional text with custom line breaks.
25 */
26
27 #include <assert.h>
28 #include <stdio.h>
29
30 #include <wine/test.h>
31 #include <windows.h>
32 #include <usp10.h>
33
34 typedef struct _itemTest {
35 char todo_flag[4];
36 int iCharPos;
37 int fRTL;
38 int fLayoutRTL;
39 int uBidiLevel;
40 } itemTest;
41
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)
45 {
46 HRESULT hr;
47 int x, outnItems;
48 SCRIPT_ITEM outpItems[15];
49
50 hr = ScriptItemize(string, cchString, 15, Control, State, outpItems, &outnItems);
51 winetest_ok(!hr, "ScriptItemize should return S_OK not %08x\n", hr);
52 if (nItemsToDo)
53 todo_wine winetest_ok(outnItems == nItems, "Wrong number of items\n");
54 else
55 winetest_ok(outnItems == nItems, "Wrong number of items\n");
56 for (x = 0; x <= outnItems; x++)
57 {
58 if (items[x].todo_flag[0])
59 todo_wine winetest_ok(outpItems[x].iCharPos == items[x].iCharPos, "%i:Wrong CharPos\n",x);
60 else
61 winetest_ok(outpItems[x].iCharPos == items[x].iCharPos, "%i:Wrong CharPos (%i)\n",x,outpItems[x].iCharPos);
62
63 if (items[x].todo_flag[1])
64 todo_wine winetest_ok(outpItems[x].a.fRTL == items[x].fRTL, "%i:Wrong fRTL\n",x);
65 else
66 winetest_ok(outpItems[x].a.fRTL == items[x].fRTL, "%i:Wrong fRTL(%i)\n",x,outpItems[x].a.fRTL);
67 if (items[x].todo_flag[2])
68 todo_wine winetest_ok(outpItems[x].a.fLayoutRTL == items[x].fLayoutRTL, "%i:Wrong fLayoutRTL\n",x);
69 else
70 winetest_ok(outpItems[x].a.fLayoutRTL == items[x].fLayoutRTL, "%i:Wrong fLayoutRTL(%i)\n",x,outpItems[x].a.fLayoutRTL);
71 if (items[x].todo_flag[3])
72 todo_wine winetest_ok(outpItems[x].a.s.uBidiLevel == items[x].uBidiLevel, "%i:Wrong BidiLevel\n",x);
73 else
74 winetest_ok(outpItems[x].a.s.uBidiLevel == items[x].uBidiLevel, "%i:Wrong BidiLevel(%i)\n",x,outpItems[x].a.s.uBidiLevel);
75 }
76 }
77
78 #define test_items_ok(a,b,c,d,e,f,g) (winetest_set_location(__FILE__,__LINE__), 0) ? 0 : _test_items_ok(a,b,c,d,e,f,g)
79
80
81 static void test_ScriptItemize( void )
82 {
83 static const WCHAR test1[] = {'t', 'e', 's', 't',0};
84 static const itemTest t11[2] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},4,0,0,0}};
85 static const itemTest t12[2] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},4,0,0,0}};
86
87 /* Arabic, English*/
88 static const WCHAR test2[] = {'1','2','3','-','5','2',0x064a,0x064f,0x0633,0x0627,0x0648,0x0650,0x064a,'7','1','.',0};
89 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}};
90 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}};
91 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}};
92
93 /* Thai */
94 static const WCHAR test3[] =
95 {0x0e04,0x0e27,0x0e32,0x0e21,0x0e1e,0x0e22,0x0e32,0x0e22,0x0e32, 0x0e21
96 ,0x0e2d,0x0e22,0x0e39,0x0e48,0x0e17,0x0e35,0x0e48,0x0e44,0x0e2b,0x0e19
97 ,0x0e04,0x0e27,0x0e32,0x0e21,0x0e2a, 0x0e33,0x0e40,0x0e23,0x0e47,0x0e08,
98 0x0e2d,0x0e22,0x0e39,0x0e48,0x0e17,0x0e35,0x0e48,0x0e19,0x0e31,0x0e48,0x0e19,0};
99
100 static const itemTest t31[2] = {{{0,0,0,0},0,0,0,0},{{0,0,0,0},41,0,0,0}};
101 static const itemTest t32[2] = {{{0,0,0,0},0,0,0,2},{{0,0,0,0},41,0,0,0}};
102
103 static const WCHAR test4[] = {'1','2','3','-','5','2',' ','i','s',' ','7','1','.',0};
104
105 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}};
106 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},{{1,0,0,1},10,0,0,2},{{1,0,0,0},12,0,0,0}};
107
108 /* Arabic */
109 static const WCHAR test5[] =
110 {0x0627,0x0644,0x0635,0x0651,0x0650,0x062d,0x0629,0x064f,' ',0x062a,0x064e,
111 0x0627,0x062c,0x064c,' ',0x0639,0x064e,0x0644,0x0649,' ',
112 0x0631,0x064f,0x0624,0x0648,0x0633,0x0650,' ',0x0627,0x0644
113 ,0x0623,0x0635,0x0650,0x062d,0x0651,0x064e,0x0627,0x0621,0x0650,0};
114 static const itemTest t51[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},38,0,0,0}};
115
116 /* Hebrew */
117 static const WCHAR test6[] = {0x05e9, 0x05dc, 0x05d5, 0x05dd, '.',0};
118 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}};
119 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}};
120 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};
121 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}};
122 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}};
123 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}};
124 static const WCHAR test8[] = {0x0633, 0x0644, 0x0627, 0x0645,0};
125 static const itemTest t81[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,0}};
126
127 /* Syriac (Like Arabic )*/
128 static const WCHAR test9[] = {0x0710, 0x0712, 0x0712, 0x0714, '.',0};
129 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}};
130 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}};
131
132 static const WCHAR test10[] = {0x0717, 0x0718, 0x071a, 0x071b,0};
133 static const itemTest t101[2] = {{{0,0,0,0},0,1,1,1},{{0,0,0,0},4,0,0,0}};
134
135 SCRIPT_ITEM items[15];
136 SCRIPT_CONTROL Control;
137 SCRIPT_STATE State;
138 HRESULT hr;
139 int nItems;
140
141 memset(&Control, 0, sizeof(Control));
142 memset(&State, 0, sizeof(State));
143
144 hr = ScriptItemize(NULL, 4, 10, &Control, &State, items, NULL);
145 ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if pwcInChars is NULL\n");
146
147 hr = ScriptItemize(test1, 4, 10, &Control, &State, NULL, NULL);
148 ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if pItems is NULL\n");
149
150 hr = ScriptItemize(test1, 4, 1, &Control, &State, items, NULL);
151 ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if cMaxItems < 2.\n");
152
153 hr = ScriptItemize(test1, 0, 10, NULL, NULL, items, &nItems);
154 ok (hr == E_INVALIDARG, "ScriptItemize should return E_INVALIDARG if cInChars is 0\n");
155
156 test_items_ok(test1,4,NULL,NULL,1,t11,FALSE);
157 test_items_ok(test2,16,NULL,NULL,6,t21,FALSE);
158 test_items_ok(test3,41,NULL,NULL,1,t31,FALSE);
159 test_items_ok(test4,12,NULL,NULL,5,t41,FALSE);
160 test_items_ok(test5,38,NULL,NULL,1,t51,FALSE);
161 test_items_ok(test6,5,NULL,NULL,2,t61,FALSE);
162 test_items_ok(test7,29,NULL,NULL,3,t71,FALSE);
163 test_items_ok(test8,4,NULL,NULL,1,t81,FALSE);
164 test_items_ok(test9,5,NULL,NULL,2,t91,FALSE);
165 test_items_ok(test10,4,NULL,NULL,1,t101,FALSE);
166
167 State.uBidiLevel = 0;
168 test_items_ok(test1,4,&Control,&State,1,t11,FALSE);
169 test_items_ok(test2,16,&Control,&State,4,t22,FALSE);
170 test_items_ok(test3,41,&Control,&State,1,t31,FALSE);
171 test_items_ok(test4,12,&Control,&State,5,t41,FALSE);
172 test_items_ok(test5,38,&Control,&State,1,t51,FALSE);
173 test_items_ok(test6,5,&Control,&State,2,t61,FALSE);
174 test_items_ok(test7,29,&Control,&State,3,t72,FALSE);
175 test_items_ok(test8,4,&Control,&State,1,t81,FALSE);
176 test_items_ok(test9,5,&Control,&State,2,t91,FALSE);
177 test_items_ok(test10,4,&Control,&State,1,t101,FALSE);
178
179 State.uBidiLevel = 1;
180 test_items_ok(test1,4,&Control,&State,1,t12,FALSE);
181 test_items_ok(test2,16,&Control,&State,4,t23,FALSE);
182 test_items_ok(test3,41,&Control,&State,1,t32,FALSE);
183 test_items_ok(test4,12,&Control,&State,4,t42,TRUE);
184 test_items_ok(test5,38,&Control,&State,1,t51,FALSE);
185 test_items_ok(test6,5,&Control,&State,2,t62,FALSE);
186 test_items_ok(test7,29,&Control,&State,3,t73,FALSE);
187 test_items_ok(test8,4,&Control,&State,1,t81,FALSE);
188 test_items_ok(test9,5,&Control,&State,2,t92,FALSE);
189 test_items_ok(test10,4,&Control,&State,1,t101,FALSE);
190 }
191
192
193 static void test_ScriptShape(HDC hdc)
194 {
195 static const WCHAR test1[] = {'w', 'i', 'n', 'e',0};
196 static const WCHAR test2[] = {0x202B, 'i', 'n', 0x202C,0};
197 HRESULT hr;
198 SCRIPT_CACHE sc = NULL;
199 WORD glyphs[4], glyphs2[4], logclust[4];
200 SCRIPT_VISATTR attrs[4];
201 SCRIPT_ITEM items[2];
202 int nb;
203
204 hr = ScriptItemize(test1, 4, 2, NULL, NULL, items, NULL);
205 ok(!hr, "ScriptItemize should return S_OK not %08x\n", hr);
206 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
207
208 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, NULL, NULL, &nb);
209 ok(hr == E_INVALIDARG, "ScriptShape should return E_INVALIDARG not %08x\n", hr);
210
211 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, NULL, attrs, NULL);
212 ok(hr == E_INVALIDARG, "ScriptShape should return E_INVALIDARG not %08x\n", hr);
213
214 hr = ScriptShape(NULL, &sc, test1, 4, 4, &items[0].a, glyphs, NULL, attrs, &nb);
215 ok(hr == E_PENDING, "ScriptShape should return E_PENDING not %08x\n", hr);
216
217 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, NULL, attrs, &nb);
218 ok(broken(hr == S_OK) ||
219 hr == E_INVALIDARG || /* Vista, W2K8 */
220 hr == E_FAIL, /* WIN7 */
221 "ScriptShape should return E_FAIL or E_INVALIDARG, not %08x\n", hr);
222 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
223
224 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, logclust, attrs, &nb);
225 ok(!hr, "ScriptShape should return S_OK not %08x\n", hr);
226 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
227
228
229 memset(glyphs,-1,sizeof(glyphs));
230 memset(logclust,-1,sizeof(logclust));
231 memset(attrs,-1,sizeof(attrs));
232 hr = ScriptShape(NULL, &sc, test1, 4, 4, &items[0].a, glyphs, logclust, attrs, &nb);
233 ok(!hr, "ScriptShape should return S_OK not %08x\n", hr);
234 ok(nb == 4, "Wrong number of items\n");
235 ok(logclust[0] == 0, "clusters out of order\n");
236 ok(logclust[1] == 1, "clusters out of order\n");
237 ok(logclust[2] == 2, "clusters out of order\n");
238 ok(logclust[3] == 3, "clusters out of order\n");
239 ok(attrs[0].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
240 ok(attrs[1].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
241 ok(attrs[2].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
242 ok(attrs[3].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
243 ok(attrs[0].fClusterStart == 1, "fClusterStart incorrect\n");
244 ok(attrs[1].fClusterStart == 1, "fClusterStart incorrect\n");
245 ok(attrs[2].fClusterStart == 1, "fClusterStart incorrect\n");
246 ok(attrs[3].fClusterStart == 1, "fClusterStart incorrect\n");
247 ok(attrs[0].fDiacritic == 0, "fDiacritic incorrect\n");
248 ok(attrs[1].fDiacritic == 0, "fDiacritic incorrect\n");
249 ok(attrs[2].fDiacritic == 0, "fDiacritic incorrect\n");
250 ok(attrs[3].fDiacritic == 0, "fDiacritic incorrect\n");
251 ok(attrs[0].fZeroWidth == 0, "fZeroWidth incorrect\n");
252 ok(attrs[1].fZeroWidth == 0, "fZeroWidth incorrect\n");
253 ok(attrs[2].fZeroWidth == 0, "fZeroWidth incorrect\n");
254 ok(attrs[3].fZeroWidth == 0, "fZeroWidth incorrect\n");
255
256 ScriptFreeCache(&sc);
257 sc = NULL;
258
259 memset(glyphs2,-1,sizeof(glyphs2));
260 memset(logclust,-1,sizeof(logclust));
261 memset(attrs,-1,sizeof(attrs));
262 hr = ScriptShape(hdc, &sc, test2, 4, 4, &items[0].a, glyphs2, logclust, attrs, &nb);
263 ok(hr == S_OK, "ScriptShape should return S_OK not %08x\n", hr);
264 ok(nb == 4, "Wrong number of items\n");
265 ok(glyphs2[0] == 0 || broken(glyphs2[0] == 0x80), "Incorrect glyph for 0x202B\n");
266 ok(glyphs2[3] == 0 || broken(glyphs2[3] == 0x80), "Incorrect glyph for 0x202C\n");
267 ok(logclust[0] == 0, "clusters out of order\n");
268 ok(logclust[1] == 1, "clusters out of order\n");
269 ok(logclust[2] == 2, "clusters out of order\n");
270 ok(logclust[3] == 3, "clusters out of order\n");
271 ok(attrs[0].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
272 ok(attrs[1].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
273 ok(attrs[2].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
274 ok(attrs[3].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
275 ok(attrs[0].fClusterStart == 1, "fClusterStart incorrect\n");
276 ok(attrs[1].fClusterStart == 1, "fClusterStart incorrect\n");
277 ok(attrs[2].fClusterStart == 1, "fClusterStart incorrect\n");
278 ok(attrs[3].fClusterStart == 1, "fClusterStart incorrect\n");
279 ok(attrs[0].fDiacritic == 0, "fDiacritic incorrect\n");
280 ok(attrs[1].fDiacritic == 0, "fDiacritic incorrect\n");
281 ok(attrs[2].fDiacritic == 0, "fDiacritic incorrect\n");
282 ok(attrs[3].fDiacritic == 0, "fDiacritic incorrect\n");
283 ok(attrs[0].fZeroWidth == 0, "fZeroWidth incorrect\n");
284 ok(attrs[1].fZeroWidth == 0, "fZeroWidth incorrect\n");
285 ok(attrs[2].fZeroWidth == 0, "fZeroWidth incorrect\n");
286 ok(attrs[3].fZeroWidth == 0, "fZeroWidth incorrect\n");
287
288 /* modify LTR to RTL */
289 items[0].a.fRTL = 1;
290 memset(glyphs2,-1,sizeof(glyphs2));
291 memset(logclust,-1,sizeof(logclust));
292 memset(attrs,-1,sizeof(attrs));
293 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs2, logclust, attrs, &nb);
294 ok(!hr, "ScriptShape should return S_OK not %08x\n", hr);
295 ok(nb == 4, "Wrong number of items\n");
296 ok(glyphs2[0] == glyphs[3], "Glyphs not reordered properly\n");
297 ok(glyphs2[1] == glyphs[2], "Glyphs not reordered properly\n");
298 ok(glyphs2[2] == glyphs[1], "Glyphs not reordered properly\n");
299 ok(glyphs2[3] == glyphs[0], "Glyphs not reordered properly\n");
300 ok(logclust[0] == 3, "clusters out of order\n");
301 ok(logclust[1] == 2, "clusters out of order\n");
302 ok(logclust[2] == 1, "clusters out of order\n");
303 ok(logclust[3] == 0, "clusters out of order\n");
304 ok(attrs[0].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
305 ok(attrs[1].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
306 ok(attrs[2].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
307 ok(attrs[3].uJustification == SCRIPT_JUSTIFY_CHARACTER, "uJustification incorrect\n");
308 ok(attrs[0].fClusterStart == 1, "fClusterStart incorrect\n");
309 ok(attrs[1].fClusterStart == 1, "fClusterStart incorrect\n");
310 ok(attrs[2].fClusterStart == 1, "fClusterStart incorrect\n");
311 ok(attrs[3].fClusterStart == 1, "fClusterStart incorrect\n");
312 ok(attrs[0].fDiacritic == 0, "fDiacritic incorrect\n");
313 ok(attrs[1].fDiacritic == 0, "fDiacritic incorrect\n");
314 ok(attrs[2].fDiacritic == 0, "fDiacritic incorrect\n");
315 ok(attrs[3].fDiacritic == 0, "fDiacritic incorrect\n");
316 ok(attrs[0].fZeroWidth == 0, "fZeroWidth incorrect\n");
317 ok(attrs[1].fZeroWidth == 0, "fZeroWidth incorrect\n");
318 ok(attrs[2].fZeroWidth == 0, "fZeroWidth incorrect\n");
319 ok(attrs[3].fZeroWidth == 0, "fZeroWidth incorrect\n");
320
321 ScriptFreeCache(&sc);
322 }
323
324 static void test_ScriptPlace(HDC hdc)
325 {
326 static const WCHAR test1[] = {'t', 'e', 's', 't',0};
327 BOOL ret;
328 HRESULT hr;
329 SCRIPT_CACHE sc = NULL;
330 WORD glyphs[4], logclust[4];
331 SCRIPT_VISATTR attrs[4];
332 SCRIPT_ITEM items[2];
333 int nb, widths[4];
334 GOFFSET offset[4];
335 ABC abc[4];
336
337 hr = ScriptItemize(test1, 4, 2, NULL, NULL, items, NULL);
338 ok(!hr, "ScriptItemize should return S_OK not %08x\n", hr);
339 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
340
341 hr = ScriptShape(hdc, &sc, test1, 4, 4, &items[0].a, glyphs, logclust, attrs, &nb);
342 ok(!hr, "ScriptShape should return S_OK not %08x\n", hr);
343 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
344
345 hr = ScriptPlace(hdc, &sc, glyphs, 4, NULL, &items[0].a, widths, NULL, NULL);
346 ok(hr == E_INVALIDARG, "ScriptPlace should return E_INVALIDARG not %08x\n", hr);
347
348 hr = ScriptPlace(NULL, &sc, glyphs, 4, attrs, &items[0].a, widths, NULL, NULL);
349 ok(broken(hr == E_PENDING) ||
350 hr == E_INVALIDARG || /* Vista, W2K8 */
351 hr == E_FAIL, /* WIN7 */
352 "ScriptPlace should return E_FAIL or E_INVALIDARG, not %08x\n", hr);
353
354 hr = ScriptPlace(NULL, &sc, glyphs, 4, attrs, &items[0].a, widths, offset, NULL);
355 ok(hr == E_PENDING, "ScriptPlace should return E_PENDING not %08x\n", hr);
356
357 hr = ScriptPlace(NULL, &sc, glyphs, 4, attrs, &items[0].a, widths, NULL, abc);
358 ok(broken(hr == E_PENDING) ||
359 hr == E_INVALIDARG || /* Vista, W2K8 */
360 hr == E_FAIL, /* WIN7 */
361 "ScriptPlace should return E_FAIL or E_INVALIDARG, not %08x\n", hr);
362
363 hr = ScriptPlace(hdc, &sc, glyphs, 4, attrs, &items[0].a, widths, offset, NULL);
364 ok(!hr, "ScriptPlace should return S_OK not %08x\n", hr);
365 ok(items[0].a.fNoGlyphIndex == FALSE, "fNoGlyphIndex TRUE\n");
366
367 ret = ExtTextOutW(hdc, 1, 1, 0, NULL, glyphs, 4, widths);
368 ok(ret, "ExtTextOutW should return TRUE\n");
369
370 ScriptFreeCache(&sc);
371 }
372
373 static void test_ScriptItemIzeShapePlace(HDC hdc, unsigned short pwOutGlyphs[256])
374 {
375 HRESULT hr;
376 int iMaxProps;
377 const SCRIPT_PROPERTIES **ppSp;
378
379 int cInChars;
380 int cMaxItems;
381 SCRIPT_ITEM pItem[255];
382 int pcItems;
383 WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
384 WCHAR TestItem2[] = {'T', 'e', 's', 't', 'b', 0};
385 WCHAR TestItem3[] = {'T', 'e', 's', 't', 'c',' ','1','2','3',' ',' ','e','n','d',0};
386 WCHAR TestItem4[] = {'T', 'e', 's', 't', 'd',' ',0x0684,0x0694,0x06a4,' ',' ','\r','\n','e','n','d',0};
387 WCHAR TestItem5[] = {0x0684,'T','e','s','t','e',' ',0x0684,0x0694,0x06a4,' ',' ','e','n','d',0};
388 WCHAR TestItem6[] = {'T', 'e', 's', 't', 'f',' ',' ',' ','\r','\n','e','n','d',0};
389
390 SCRIPT_CACHE psc;
391 int cChars;
392 int cMaxGlyphs;
393 unsigned short pwOutGlyphs1[256];
394 unsigned short pwOutGlyphs2[256];
395 unsigned short pwLogClust[256];
396 SCRIPT_VISATTR psva[256];
397 int pcGlyphs;
398 int piAdvance[256];
399 GOFFSET pGoffset[256];
400 ABC pABC[256];
401 int cnt;
402
403 /* Start testing usp10 functions */
404 /* This test determines that the pointer returned by ScriptGetProperties is valid
405 * by checking a known value in the table */
406 hr = ScriptGetProperties(&ppSp, &iMaxProps);
407 trace("number of script properties %d\n", iMaxProps);
408 ok (iMaxProps > 0, "Number of scripts returned should not be 0\n");
409 if (iMaxProps > 0)
410 ok( ppSp[5]->langid == 9, "Langid[5] not = to 9\n"); /* Check a known value to ensure */
411 /* ptrs work */
412
413 /* This is a valid test that will cause parsing to take place */
414 cInChars = 5;
415 cMaxItems = 255;
416 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
417 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
418 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
419 * returned. */
420 ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
421 if (pcItems > 0)
422 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
423 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
424 pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
425
426 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
427 * ie. ScriptItemize has succeeded and that pItem has been set */
428 cInChars = 5;
429 cMaxItems = 255;
430 if (hr == 0) {
431 psc = NULL; /* must be null on first call */
432 cChars = cInChars;
433 cMaxGlyphs = cInChars;
434 hr = ScriptShape(NULL, &psc, TestItem1, cChars,
435 cMaxGlyphs, &pItem[0].a,
436 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
437 ok (hr == E_PENDING, "If psc is NULL (%08x) the E_PENDING should be returned\n", hr);
438 cMaxGlyphs = 4;
439 hr = ScriptShape(hdc, &psc, TestItem1, cChars,
440 cMaxGlyphs, &pItem[0].a,
441 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
442 ok (hr == E_OUTOFMEMORY, "If not enough output area cChars (%d) is > than CMaxGlyphs "
443 "(%d) but not E_OUTOFMEMORY\n",
444 cChars, cMaxGlyphs);
445 cMaxGlyphs = 256;
446 hr = ScriptShape(hdc, &psc, TestItem1, cChars,
447 cMaxGlyphs, &pItem[0].a,
448 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
449 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
450 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
451 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
452 if (hr ==0) {
453 hr = ScriptPlace(hdc, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
454 pGoffset, pABC);
455 ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
456 hr = ScriptPlace(NULL, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
457 pGoffset, pABC);
458 ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
459 for (cnt=0; cnt < pcGlyphs; cnt++)
460 pwOutGlyphs[cnt] = pwOutGlyphs1[cnt]; /* Send to next function */
461 }
462
463 /* This test will check to make sure that SCRIPT_CACHE is reused and that not translation *
464 * takes place if fNoGlyphIndex is set. */
465
466 cInChars = 5;
467 cMaxItems = 255;
468 hr = ScriptItemize(TestItem2, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
469 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
470 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
471 * returned. */
472 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
473 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
474 pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
475 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue */
476 if (hr == 0) {
477 cChars = cInChars;
478 cMaxGlyphs = 256;
479 pItem[0].a.fNoGlyphIndex = 1; /* say no translate */
480 hr = ScriptShape(NULL, &psc, TestItem2, cChars,
481 cMaxGlyphs, &pItem[0].a,
482 pwOutGlyphs2, pwLogClust, psva, &pcGlyphs);
483 ok (hr != E_PENDING, "If psc should not be NULL (%08x) and the E_PENDING should be returned\n", hr);
484 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
485 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
486 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
487 for (cnt=0; cnt < cChars && TestItem2[cnt] == pwOutGlyphs2[cnt]; cnt++) {}
488 ok (cnt == cChars, "Translation to place when told not to. WCHAR %d - %04x != %04x\n",
489 cnt, TestItem2[cnt], pwOutGlyphs2[cnt]);
490 if (hr ==0) {
491 hr = ScriptPlace(hdc, &psc, pwOutGlyphs2, pcGlyphs, psva, &pItem[0].a, piAdvance,
492 pGoffset, pABC);
493 ok (hr == 0, "ScriptPlace should return 0 not (%08x)\n", hr);
494 }
495 }
496 hr = ScriptFreeCache( &psc);
497 ok (!psc, "psc is not null after ScriptFreeCache\n");
498
499 }
500
501 /* This is a valid test that will cause parsing to take place and create 3 script_items */
502 cInChars = (sizeof(TestItem3)/2)-1;
503 cMaxItems = 255;
504 hr = ScriptItemize(TestItem3, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
505 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
506 if (hr == 0)
507 {
508 ok (pcItems == 3, "The number of SCRIPT_ITEMS should be 3 not %d\n", pcItems);
509 if (pcItems > 2)
510 {
511 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == 6,
512 "Start pos [0] not = 0 (%d) or end pos [1] not = %d\n",
513 pItem[0].iCharPos, pItem[1].iCharPos);
514 ok (pItem[1].iCharPos == 6 && pItem[2].iCharPos == 11,
515 "Start pos [1] not = 6 (%d) or end pos [2] not = 11 (%d)\n",
516 pItem[1].iCharPos, pItem[2].iCharPos);
517 ok (pItem[2].iCharPos == 11 && pItem[3].iCharPos == cInChars,
518 "Start pos [2] not = 11 (%d) or end [3] pos not = 14 (%d), cInChars = %d\n",
519 pItem[2].iCharPos, pItem[3].iCharPos, cInChars);
520 }
521 }
522
523 /* This is a valid test that will cause parsing to take place and create 5 script_items */
524 cInChars = (sizeof(TestItem4)/2)-1;
525 cMaxItems = 255;
526 hr = ScriptItemize(TestItem4, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
527 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
528 if (hr == 0)
529 {
530 ok (pcItems == 5, "The number of SCRIPT_ITEMS should be 5 not %d\n", pcItems);
531 if (pcItems > 4)
532 {
533 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == 6,
534 "Start pos [0] not = 0 (%d) or end pos [1] not = %d\n",
535 pItem[0].iCharPos, pItem[1].iCharPos);
536 ok (pItem[0].a.s.uBidiLevel == 0, "Should have been bidi=0 not %d\n",
537 pItem[0].a.s.uBidiLevel);
538 ok (pItem[1].iCharPos == 6 && pItem[2].iCharPos == 11,
539 "Start pos [1] not = 6 (%d) or end pos [2] not = 11 (%d)\n",
540 pItem[1].iCharPos, pItem[2].iCharPos);
541 ok (pItem[1].a.s.uBidiLevel == 1, "Should have been bidi=1 not %d\n",
542 pItem[1].a.s.uBidiLevel);
543 ok (pItem[2].iCharPos == 11 && pItem[3].iCharPos == 12,
544 "Start pos [2] not = 11 (%d) or end [3] pos not = 12 (%d)\n",
545 pItem[2].iCharPos, pItem[3].iCharPos);
546 ok (pItem[2].a.s.uBidiLevel == 0, "Should have been bidi=0 not %d\n",
547 pItem[2].a.s.uBidiLevel);
548 ok (pItem[3].iCharPos == 12 && pItem[4].iCharPos == 13,
549 "Start pos [3] not = 12 (%d) or end [4] pos not = 13 (%d)\n",
550 pItem[3].iCharPos, pItem[4].iCharPos);
551 ok (pItem[3].a.s.uBidiLevel == 0, "Should have been bidi=0 not %d\n",
552 pItem[3].a.s.uBidiLevel);
553 ok (pItem[4].iCharPos == 13 && pItem[5].iCharPos == cInChars,
554 "Start pos [4] not = 13 (%d) or end [5] pos not = 16 (%d), cInChars = %d\n",
555 pItem[4].iCharPos, pItem[5].iCharPos, cInChars);
556 }
557 }
558
559 /*
560 * This test is for when the first unicode character requires bidi support
561 */
562 cInChars = (sizeof(TestItem5)-1)/sizeof(WCHAR);
563 hr = ScriptItemize(TestItem5, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
564 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
565 ok (pcItems == 4, "There should have been 4 items, found %d\n", pcItems);
566 ok (pItem[0].a.s.uBidiLevel == 1, "The first character should have been bidi=1 not %d\n",
567 pItem[0].a.s.uBidiLevel);
568
569 /* This test checks to make sure that the test to see if there are sufficient buffers to store *
570 * the pointer to the last char works. Note that windows often needs a greater number of *
571 * SCRIPT_ITEMS to process a string than is returned in pcItems. */
572 cInChars = (sizeof(TestItem6)/2)-1;
573 cMaxItems = 4;
574 hr = ScriptItemize(TestItem6, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
575 ok (hr == E_OUTOFMEMORY, "ScriptItemize should return E_OUTOFMEMORY, returned %08x\n", hr);
576
577 }
578
579 static void test_ScriptGetCMap(HDC hdc, unsigned short pwOutGlyphs[256])
580 {
581 HRESULT hr;
582 SCRIPT_CACHE psc = NULL;
583 int cInChars;
584 int cChars;
585 unsigned short pwOutGlyphs2[256];
586 unsigned short pwOutGlyphs3[256];
587 DWORD dwFlags;
588 int cnt;
589
590 static const WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
591 static const WCHAR TestItem2[] = {0x202B, 'i', 'n', 0x202C,0};
592 static const WCHAR TestItem3[] = {'a','b','c','d','(','<','{','[',0x2039,0};
593 static const WCHAR TestItem3b[] = {'a','b','c','d',')','>','}',']',0x203A,0};
594
595 /* Check to make sure that SCRIPT_CACHE gets allocated ok */
596 dwFlags = 0;
597 cInChars = cChars = 5;
598 /* Some sanity checks for ScriptGetCMap */
599
600 hr = ScriptGetCMap(NULL, NULL, NULL, 0, 0, NULL);
601 ok( hr == E_INVALIDARG, "(NULL,NULL,NULL,0,0,NULL), "
602 "expected E_INVALIDARG, got %08x\n", hr);
603
604 hr = ScriptGetCMap(NULL, NULL, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
605 ok( hr == E_INVALIDARG, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
606 "expected E_INVALIDARG, got %08x\n", hr);
607
608 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
609 psc = NULL;
610 hr = ScriptGetCMap(NULL, &psc, TestItem1, cInChars, 0, pwOutGlyphs3);
611 ok( hr == E_PENDING, "(NULL,&psc,NULL,0,0,NULL), expected E_PENDING, "
612 "got %08x\n", hr);
613 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
614
615 /* Set psc to NULL but add hdc, to be able to check if a pointer is returned in psc */
616 psc = NULL;
617 hr = ScriptGetCMap(hdc, &psc, TestItem1, cInChars, 0, pwOutGlyphs3);
618 ok( hr == S_OK, "ScriptGetCMap(NULL,&psc,NULL,0,0,NULL), expected S_OK, "
619 "got %08x\n", hr);
620 ok( psc != NULL, "ScritpGetCMap expected psc to be not NULL\n");
621 ScriptFreeCache( &psc);
622
623 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
624 psc = NULL;
625 hr = ScriptGetCMap(NULL, &psc, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
626 ok( hr == E_PENDING, "(NULL,&psc,), expected E_PENDING, got %08x\n", hr);
627 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
628 /* Check to see if the results are the same as those returned by ScriptShape */
629 hr = ScriptGetCMap(hdc, &psc, TestItem1, cInChars, dwFlags, pwOutGlyphs3);
630 ok (hr == 0, "ScriptGetCMap should return 0 not (%08x)\n", hr);
631 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
632 for (cnt=0; cnt < cChars && pwOutGlyphs[cnt] == pwOutGlyphs3[cnt]; cnt++) {}
633 ok (cnt == cInChars, "Translation not correct. WCHAR %d - %04x != %04x\n",
634 cnt, pwOutGlyphs[cnt], pwOutGlyphs3[cnt]);
635
636 hr = ScriptFreeCache( &psc);
637 ok (!psc, "psc is not null after ScriptFreeCache\n");
638
639 cInChars = cChars = 4;
640 hr = ScriptGetCMap(hdc, &psc, TestItem2, cInChars, dwFlags, pwOutGlyphs3);
641 ok (hr == S_FALSE, "ScriptGetCMap should return S_FALSE not (%08x)\n", hr);
642 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
643 ok(pwOutGlyphs3[0] == 0 || broken(pwOutGlyphs3[0] == 0x80), "Glyph 0 should be default glyph\n");
644 ok(pwOutGlyphs3[3] == 0 || broken(pwOutGlyphs3[0] == 0x80), "Glyph 0 should be default glyph\n");
645
646
647 cInChars = cChars = 9;
648 hr = ScriptGetCMap(hdc, &psc, TestItem3b, cInChars, dwFlags, pwOutGlyphs2);
649 ok (hr == S_OK, "ScriptGetCMap should return S_OK not (%08x)\n", hr);
650 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
651
652 cInChars = cChars = 9;
653 dwFlags = SGCM_RTL;
654 hr = ScriptGetCMap(hdc, &psc, TestItem3, cInChars, dwFlags, pwOutGlyphs3);
655 ok (hr == S_OK, "ScriptGetCMap should return S_OK not (%08x)\n", hr);
656 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
657 ok(pwOutGlyphs3[0] == pwOutGlyphs2[0], "glyph incorrectly altered\n");
658 ok(pwOutGlyphs3[1] == pwOutGlyphs2[1], "glyph incorreclty altered\n");
659 ok(pwOutGlyphs3[2] == pwOutGlyphs2[2], "glyph incorreclty altered\n");
660 ok(pwOutGlyphs3[3] == pwOutGlyphs2[3], "glyph incorreclty altered\n");
661 ok(pwOutGlyphs3[4] == pwOutGlyphs2[4], "glyph not mirrored correctly\n");
662 ok(pwOutGlyphs3[5] == pwOutGlyphs2[5], "glyph not mirrored correctly\n");
663 ok(pwOutGlyphs3[6] == pwOutGlyphs2[6], "glyph not mirrored correctly\n");
664 ok(pwOutGlyphs3[7] == pwOutGlyphs2[7], "glyph not mirrored correctly\n");
665 ok(pwOutGlyphs3[8] == pwOutGlyphs2[8], "glyph not mirrored correctly\n");
666
667 hr = ScriptFreeCache( &psc);
668 ok (!psc, "psc is not null after ScriptFreeCache\n");
669 }
670
671 static void test_ScriptGetFontProperties(HDC hdc)
672 {
673 HRESULT hr;
674 SCRIPT_CACHE psc,old_psc;
675 SCRIPT_FONTPROPERTIES sfp;
676
677 /* Some sanity checks for ScriptGetFontProperties */
678
679 hr = ScriptGetFontProperties(NULL,NULL,NULL);
680 ok( hr == E_INVALIDARG, "(NULL,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr);
681
682 hr = ScriptGetFontProperties(NULL,NULL,&sfp);
683 ok( hr == E_INVALIDARG, "(NULL,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr);
684
685 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
686 psc = NULL;
687 hr = ScriptGetFontProperties(NULL,&psc,NULL);
688 ok( hr == E_INVALIDARG, "(NULL,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr);
689 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
690
691 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
692 psc = NULL;
693 hr = ScriptGetFontProperties(NULL,&psc,&sfp);
694 ok( hr == E_PENDING, "(NULL,&psc,&sfp), expected E_PENDING, got %08x\n", hr);
695 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
696
697 hr = ScriptGetFontProperties(hdc,NULL,NULL);
698 ok( hr == E_INVALIDARG, "(hdc,NULL,NULL), expected E_INVALIDARG, got %08x\n", hr);
699
700 hr = ScriptGetFontProperties(hdc,NULL,&sfp);
701 ok( hr == E_INVALIDARG, "(hdc,NULL,&sfp), expected E_INVALIDARG, got %08x\n", hr);
702
703 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
704 psc = NULL;
705 hr = ScriptGetFontProperties(hdc,&psc,NULL);
706 ok( hr == E_INVALIDARG, "(hdc,&psc,NULL), expected E_INVALIDARG, got %08x\n", hr);
707 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
708
709 /* Pass an invalid sfp */
710 psc = NULL;
711 sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES) - 1;
712 hr = ScriptGetFontProperties(hdc,&psc,&sfp);
713 ok( hr == E_INVALIDARG, "(hdc,&psc,&sfp) invalid, expected E_INVALIDARG, got %08x\n", hr);
714 ok( psc != NULL, "Expected a pointer in psc, got NULL\n");
715 ScriptFreeCache(&psc);
716 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
717
718 /* Give it the correct cBytes, we don't care about what's coming back */
719 sfp.cBytes = sizeof(SCRIPT_FONTPROPERTIES);
720 psc = NULL;
721 hr = ScriptGetFontProperties(hdc,&psc,&sfp);
722 ok( hr == S_OK, "(hdc,&psc,&sfp) partly initialized, expected S_OK, got %08x\n", hr);
723 ok( psc != NULL, "Expected a pointer in psc, got NULL\n");
724
725 /* Save the psc pointer */
726 old_psc = psc;
727 /* Now a NULL hdc again */
728 hr = ScriptGetFontProperties(NULL,&psc,&sfp);
729 ok( hr == S_OK, "(NULL,&psc,&sfp), expected S_OK, got %08x\n", hr);
730 ok( psc == old_psc, "Expected psc not to be changed, was %p is now %p\n", old_psc, psc);
731 ScriptFreeCache(&psc);
732 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
733 }
734
735 static void test_ScriptTextOut(HDC hdc)
736 {
737 HRESULT hr;
738
739 int cInChars;
740 int cMaxItems;
741 SCRIPT_ITEM pItem[255];
742 int pcItems;
743 WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
744
745 SCRIPT_CACHE psc;
746 int cChars;
747 int cMaxGlyphs;
748 unsigned short pwOutGlyphs1[256];
749 WORD pwLogClust[256];
750 SCRIPT_VISATTR psva[256];
751 int pcGlyphs;
752 int piAdvance[256];
753 GOFFSET pGoffset[256];
754 ABC pABC[256];
755 RECT rect;
756 int piX;
757 int iCP = 1;
758 BOOL fTrailing = FALSE;
759 SCRIPT_LOGATTR *psla;
760 SCRIPT_LOGATTR sla[256];
761
762 /* This is a valid test that will cause parsing to take place */
763 cInChars = 5;
764 cMaxItems = 255;
765 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
766 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
767 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
768 * returned. */
769 ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
770 if (pcItems > 0)
771 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
772 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
773 pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
774
775 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
776 * ie. ScriptItemize has succeeded and that pItem has been set */
777 cInChars = 5;
778 cMaxItems = 255;
779 if (hr == 0) {
780 psc = NULL; /* must be null on first call */
781 cChars = cInChars;
782 cMaxGlyphs = cInChars;
783 cMaxGlyphs = 256;
784 hr = ScriptShape(hdc, &psc, TestItem1, cChars,
785 cMaxGlyphs, &pItem[0].a,
786 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
787 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
788 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
789 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
790 if (hr ==0) {
791 /* Note hdc is needed as glyph info is not yet in psc */
792 hr = ScriptPlace(hdc, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
793 pGoffset, pABC);
794 ok (hr == 0, "Should return 0 not (%08x)\n", hr);
795 ScriptFreeCache(&psc); /* Get rid of psc for next test set */
796 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
797
798 hr = ScriptTextOut(NULL, NULL, 0, 0, 0, NULL, NULL, NULL, 0, NULL, 0, NULL, NULL, NULL);
799 ok (hr == E_INVALIDARG, "Should return 0 not (%08x)\n", hr);
800
801 hr = ScriptTextOut(NULL, NULL, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
802 piAdvance, NULL, pGoffset);
803 ok( hr == E_INVALIDARG, "(NULL,NULL,TestItem1, cInChars, dwFlags, pwOutGlyphs3), "
804 "expected E_INVALIDARG, got %08x\n", hr);
805
806 /* Set psc to NULL, to be able to check if a pointer is returned in psc */
807 psc = NULL;
808 hr = ScriptTextOut(NULL, &psc, 0, 0, 0, NULL, NULL, NULL, 0, NULL, 0,
809 NULL, NULL, NULL);
810 ok( hr == E_INVALIDARG, "(NULL,&psc,NULL,0,0,0,NULL,), expected E_INVALIDARG, "
811 "got %08x\n", hr);
812 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
813
814 /* hdc is required for this one rather than the usual optional */
815 psc = NULL;
816 hr = ScriptTextOut(NULL, &psc, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
817 piAdvance, NULL, pGoffset);
818 ok( hr == E_INVALIDARG, "(NULL,&psc,), expected E_INVALIDARG, got %08x\n", hr);
819 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
820
821 /* Set that it returns 0 status */
822 hr = ScriptTextOut(hdc, &psc, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
823 piAdvance, NULL, pGoffset);
824 ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
825
826 /* Test Rect Rgn is acceptable */
827 rect.top = 10;
828 rect.bottom = 20;
829 rect.left = 10;
830 rect.right = 40;
831 hr = ScriptTextOut(hdc, &psc, 0, 0, 0, &rect, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
832 piAdvance, NULL, pGoffset);
833 ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
834
835 iCP = 1;
836 hr = ScriptCPtoX(iCP, fTrailing, cChars, pcGlyphs, (const WORD *) &pwLogClust,
837 (const SCRIPT_VISATTR *) &psva, (const int *)&piAdvance, &pItem[0].a, &piX);
838 ok(hr == S_OK, "ScriptCPtoX Stub should return S_OK not %08x\n", hr);
839
840 psla = (SCRIPT_LOGATTR *)&sla;
841 hr = ScriptBreak(TestItem1, cChars, &pItem[0].a, psla);
842 ok(hr == S_OK, "ScriptBreak Stub should return S_OK not %08x\n", hr);
843
844 /* Clean up and go */
845 ScriptFreeCache(&psc);
846 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
847 }
848 }
849 }
850
851 static void test_ScriptTextOut2(HDC hdc)
852 {
853 /* Intent is to validate that the HDC passed into ScriptTextOut is
854 * used instead of the (possibly) invalid cached one
855 */
856 HRESULT hr;
857
858 HDC hdc1, hdc2;
859 int cInChars;
860 int cMaxItems;
861 SCRIPT_ITEM pItem[255];
862 int pcItems;
863 WCHAR TestItem1[] = {'T', 'e', 's', 't', 'a', 0};
864
865 SCRIPT_CACHE psc;
866 int cChars;
867 int cMaxGlyphs;
868 unsigned short pwOutGlyphs1[256];
869 WORD pwLogClust[256];
870 SCRIPT_VISATTR psva[256];
871 int pcGlyphs;
872 int piAdvance[256];
873 GOFFSET pGoffset[256];
874 ABC pABC[256];
875
876 /* Create an extra DC that will be used until the ScriptTextOut */
877 hdc1 = CreateCompatibleDC(hdc);
878 ok (hdc1 != 0, "CreateCompatibleDC failed to create a DC\n");
879 hdc2 = CreateCompatibleDC(hdc);
880 ok (hdc2 != 0, "CreateCompatibleDC failed to create a DC\n");
881
882 /* This is a valid test that will cause parsing to take place */
883 cInChars = 5;
884 cMaxItems = 255;
885 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
886 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
887 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
888 * returned. */
889 ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
890 if (pcItems > 0)
891 ok (pItem[0].iCharPos == 0 && pItem[1].iCharPos == cInChars,
892 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
893 pItem[0].iCharPos, cInChars, pItem[1].iCharPos);
894
895 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
896 * ie. ScriptItemize has succeeded and that pItem has been set */
897 cInChars = 5;
898 cMaxItems = 255;
899 if (hr == 0) {
900 psc = NULL; /* must be null on first call */
901 cChars = cInChars;
902 cMaxGlyphs = cInChars;
903 cMaxGlyphs = 256;
904 hr = ScriptShape(hdc2, &psc, TestItem1, cChars,
905 cMaxGlyphs, &pItem[0].a,
906 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
907 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
908 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
909 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
910 if (hr ==0) {
911 /* Note hdc is needed as glyph info is not yet in psc */
912 hr = ScriptPlace(hdc2, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
913 pGoffset, pABC);
914 ok (hr == 0, "Should return 0 not (%08x)\n", hr);
915
916 /* key part!!! cached dc is being deleted */
917 hr = DeleteDC(hdc2);
918 ok(hr == 1, "DeleteDC should return 1 not %08x\n", hr);
919
920 /* At this point the cached hdc (hdc2) has been destroyed,
921 * however, we are passing in a *real* hdc (the original hdc).
922 * The text should be written to that DC
923 */
924 hr = ScriptTextOut(hdc1, &psc, 0, 0, 0, NULL, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
925 piAdvance, NULL, pGoffset);
926 ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
927 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
928
929 DeleteDC(hdc1);
930
931 /* Clean up and go */
932 ScriptFreeCache(&psc);
933 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
934 }
935 }
936 }
937
938 static void test_ScriptTextOut3(HDC hdc)
939 {
940 HRESULT hr;
941
942 int cInChars;
943 int cMaxItems;
944 SCRIPT_ITEM pItem[255];
945 int pcItems;
946 WCHAR TestItem1[] = {' ','\r', 0};
947
948 SCRIPT_CACHE psc;
949 int cChars;
950 int cMaxGlyphs;
951 unsigned short pwOutGlyphs1[256];
952 WORD pwLogClust[256];
953 SCRIPT_VISATTR psva[256];
954 int pcGlyphs;
955 int piAdvance[256];
956 GOFFSET pGoffset[256];
957 ABC pABC[256];
958 RECT rect;
959
960 /* This is to ensure that non exisiting glyphs are translated into a valid glyph number */
961 cInChars = 2;
962 cMaxItems = 255;
963 hr = ScriptItemize(TestItem1, cInChars, cMaxItems, NULL, NULL, pItem, &pcItems);
964 ok (hr == 0, "ScriptItemize should return 0, returned %08x\n", hr);
965 /* This test is for the interim operation of ScriptItemize where only one SCRIPT_ITEM is *
966 * returned. */
967 ok (pcItems > 0, "The number of SCRIPT_ITEMS should be greater than 0\n");
968 if (pcItems > 0)
969 ok (pItem[0].iCharPos == 0 && pItem[2].iCharPos == cInChars,
970 "Start pos not = 0 (%d) or end pos not = %d (%d)\n",
971 pItem[0].iCharPos, cInChars, pItem[2].iCharPos);
972
973 /* It would appear that we have a valid SCRIPT_ANALYSIS and can continue
974 * ie. ScriptItemize has succeeded and that pItem has been set */
975 cInChars = 2;
976 cMaxItems = 255;
977 if (hr == 0) {
978 psc = NULL; /* must be null on first call */
979 cChars = cInChars;
980 cMaxGlyphs = cInChars;
981 cMaxGlyphs = 256;
982 hr = ScriptShape(hdc, &psc, TestItem1, cChars,
983 cMaxGlyphs, &pItem[0].a,
984 pwOutGlyphs1, pwLogClust, psva, &pcGlyphs);
985 ok (hr == 0, "ScriptShape should return 0 not (%08x)\n", hr);
986 ok (psc != NULL, "psc should not be null and have SCRIPT_CACHE buffer address\n");
987 ok (pcGlyphs == cChars, "Chars in (%d) should equal Glyphs out (%d)\n", cChars, pcGlyphs);
988 if (hr ==0) {
989 /* Note hdc is needed as glyph info is not yet in psc */
990 hr = ScriptPlace(hdc, &psc, pwOutGlyphs1, pcGlyphs, psva, &pItem[0].a, piAdvance,
991 pGoffset, pABC);
992 ok (hr == 0, "Should return 0 not (%08x)\n", hr);
993
994 /* Test Rect Rgn is acceptable */
995 rect.top = 10;
996 rect.bottom = 20;
997 rect.left = 10;
998 rect.right = 40;
999 hr = ScriptTextOut(hdc, &psc, 0, 0, 0, &rect, &pItem[0].a, NULL, 0, pwOutGlyphs1, pcGlyphs,
1000 piAdvance, NULL, pGoffset);
1001 ok (hr == 0, "ScriptTextOut should return 0 not (%08x)\n", hr);
1002
1003 }
1004 /* Clean up and go */
1005 ScriptFreeCache(&psc);
1006 ok( psc == NULL, "Expected psc to be NULL, got %p\n", psc);
1007 }
1008 }
1009
1010 static void test_ScriptXtoX(void)
1011 /****************************************************************************************
1012 * This routine tests the ScriptXtoCP and ScriptCPtoX functions using static variables *
1013 ****************************************************************************************/
1014 {
1015 static const WCHAR test[] = {'t', 'e', 's', 't',0};
1016 SCRIPT_ITEM items[2];
1017 int iX, iCP;
1018 int cChars;
1019 int cGlyphs;
1020 WORD pwLogClust[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1021 SCRIPT_VISATTR psva[10];
1022 int piAdvance[10] = {200, 190, 210, 180, 170, 204, 189, 195, 212, 203};
1023 int piCP, piX;
1024 int piTrailing;
1025 BOOL fTrailing;
1026 HRESULT hr;
1027
1028 hr = ScriptItemize(test, lstrlenW(test), sizeof(items)/sizeof(items[0]), NULL, NULL, items, NULL);
1029 ok(!hr, "ScriptItemize should return S_OK not %08x\n", hr);
1030
1031 iX = -1;
1032 cChars = 10;
1033 cGlyphs = 10;
1034 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
1035 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
1036 if (piTrailing)
1037 ok(piCP == -1, "Negative iX should return piCP=-1 not %d\n", piCP);
1038 else /* win2k3 */
1039 ok(piCP == 10, "Negative iX should return piCP=10 not %d\n", piCP);
1040
1041 iX = 1954;
1042 cChars = 10;
1043 cGlyphs = 10;
1044 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
1045 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
1046 if (piTrailing) /* win2k3 */
1047 ok(piCP == -1, "Negative iX should return piCP=-1 not %d\n", piCP);
1048 else
1049 ok(piCP == 10, "Negative iX should return piCP=10 not %d\n", piCP);
1050
1051 iX = 779;
1052 cChars = 10;
1053 cGlyphs = 10;
1054 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
1055 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
1056 ok(piCP == 3 ||
1057 piCP == -1, /* win2k3 */
1058 "iX=%d should return piCP=3 or piCP=-1 not %d\n", iX, piCP);
1059 ok(piTrailing == 1, "iX=%d should return piTrailing=1 not %d\n", iX, piTrailing);
1060
1061 iX = 780;
1062 cChars = 10;
1063 cGlyphs = 10;
1064 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
1065 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
1066 ok(piCP == 3 ||
1067 piCP == -1, /* win2k3 */
1068 "iX=%d should return piCP=3 or piCP=-1 not %d\n", iX, piCP);
1069 ok(piTrailing == 1, "iX=%d should return piTrailing=1 not %d\n", iX, piTrailing);
1070
1071 iX = 868;
1072 cChars = 10;
1073 cGlyphs = 10;
1074 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
1075 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
1076 ok(piCP == 4 ||
1077 piCP == -1, /* win2k3 */
1078 "iX=%d should return piCP=4 or piCP=-1 not %d\n", iX, piCP);
1079
1080 iX = 0;
1081 cChars = 10;
1082 cGlyphs = 10;
1083 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
1084 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
1085 ok(piCP == 0 ||
1086 piCP == 10, /* win2k3 */
1087 "iX=%d should return piCP=0 piCP=10 not %d\n", iX, piCP);
1088
1089 iX = 195;
1090 cChars = 10;
1091 cGlyphs = 10;
1092 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
1093 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
1094 ok(piCP == 0, "iX=%d should return piCP=0 not %d\n", iX, piCP);
1095
1096 iX = 196;
1097 cChars = 10;
1098 cGlyphs = 10;
1099 hr = ScriptXtoCP(iX, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piCP, &piTrailing);
1100 ok(hr == S_OK, "ScriptXtoCP should return S_OK not %08x\n", hr);
1101 ok(piCP == 1 ||
1102 piCP == 0, /* win2k3 */
1103 "iX=%d should return piCP=1 or piCP=0 not %d\n", iX, piCP);
1104
1105 iCP=5;
1106 fTrailing = FALSE;
1107 cChars = 10;
1108 cGlyphs = 10;
1109 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
1110 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
1111 ok(piX == 976 ||
1112 piX == 100, /* win2k3 */
1113 "iCP=%d should return piX=976 or piX=100 not %d\n", iCP, piX);
1114
1115 iCP=5;
1116 fTrailing = TRUE;
1117 cChars = 10;
1118 cGlyphs = 10;
1119 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
1120 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
1121 ok(piX == 1171 ||
1122 piX == 80, /* win2k3 */
1123 "iCP=%d should return piX=1171 or piX=80 not %d\n", iCP, piX);
1124
1125 iCP=6;
1126 fTrailing = FALSE;
1127 cChars = 10;
1128 cGlyphs = 10;
1129 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
1130 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
1131 ok(piX == 1171 ||
1132 piX == 80, /* win2k3 */
1133 "iCP=%d should return piX=1171 or piX=80 not %d\n", iCP, piX);
1134
1135 iCP=11;
1136 fTrailing = FALSE;
1137 cChars = 10;
1138 cGlyphs = 10;
1139 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
1140 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
1141 ok(piX == 1953 ||
1142 piX == 0, /* win2k3 */
1143 "iCP=%d should return piX=1953 or piX=0 not %d\n", iCP, piX);
1144
1145 iCP=11;
1146 fTrailing = TRUE;
1147 cChars = 10;
1148 cGlyphs = 10;
1149 hr = ScriptCPtoX(iCP, fTrailing, cChars, cGlyphs, pwLogClust, psva, piAdvance, &items[0].a, &piX);
1150 ok(hr == S_OK, "ScriptCPtoX should return S_OK not %08x\n", hr);
1151 ok(piX == 1953 ||
1152 piX == 0, /* win2k3 */
1153 "iCP=%d should return piX=1953 or piX=0 not %d\n", iCP, piX);
1154 }
1155
1156 static void test_ScriptString(HDC hdc)
1157 {
1158 /*******************************************************************************************
1159 *
1160 * This set of tests are for the string functions of uniscribe. The ScriptStringAnalyse
1161 * function allocates memory pointed to by the SCRIPT_STRING_ANALYSIS ssa pointer. This
1162 * memory if freed by ScriptStringFree. There needs to be a valid hdc for this as
1163 * ScriptStringAnalyse calls ScriptSItemize, ScriptShape and ScriptPlace which require it.
1164 *
1165 */
1166
1167 HRESULT hr;
1168 WCHAR teststr[] = {'T','e','s','t','1',' ','a','2','b','3', '\0'};
1169 int len = (sizeof(teststr) / sizeof(WCHAR)) - 1;
1170 int Glyphs = len * 2 + 16;
1171 int Charset;
1172 DWORD Flags = SSA_GLYPHS;
1173 int ReqWidth = 100;
1174 SCRIPT_CONTROL Control;
1175 SCRIPT_STATE State;
1176 const int Dx[5] = {10, 10, 10, 10, 10};
1177 SCRIPT_TABDEF Tabdef;
1178 const BYTE InClass = 0;
1179 SCRIPT_STRING_ANALYSIS ssa = NULL;
1180
1181 int X = 10;
1182 int Y = 100;
1183 UINT Options = 0;
1184 const RECT rc = {0, 50, 100, 100};
1185 int MinSel = 0;
1186 int MaxSel = 0;
1187 BOOL Disabled = FALSE;
1188 const int *clip_len;
1189 int i;
1190 UINT *order;
1191
1192
1193 Charset = -1; /* this flag indicates unicode input */
1194 /* Test without hdc to get E_PENDING */
1195 hr = ScriptStringAnalyse( NULL, teststr, len, Glyphs, Charset, Flags,
1196 ReqWidth, &Control, &State, Dx, &Tabdef,
1197 &InClass, &ssa);
1198 ok(hr == E_PENDING, "ScriptStringAnalyse Stub should return E_PENDING not %08x\n", hr);
1199
1200 /* test with hdc, this should be a valid test */
1201 hr = ScriptStringAnalyse( hdc, teststr, len, Glyphs, Charset, Flags,
1202 ReqWidth, &Control, &State, Dx, &Tabdef,
1203 &InClass, &ssa);
1204 ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
1205 ScriptStringFree(&ssa);
1206
1207 /* test makes sure that a call with a valid pssa still works */
1208 hr = ScriptStringAnalyse( hdc, teststr, len, Glyphs, Charset, Flags,
1209 ReqWidth, &Control, &State, Dx, &Tabdef,
1210 &InClass, &ssa);
1211 ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
1212 ok(ssa != NULL, "ScriptStringAnalyse pssa should not be NULL\n");
1213
1214 if (hr == S_OK)
1215 {
1216 hr = ScriptStringOut(ssa, X, Y, Options, &rc, MinSel, MaxSel, Disabled);
1217 ok(hr == S_OK, "ScriptStringOut should return S_OK not %08x\n", hr);
1218 }
1219
1220 clip_len = ScriptString_pcOutChars(ssa);
1221 ok(*clip_len == len, "ScriptString_pcOutChars failed, got %d, expected %d\n", *clip_len, len);
1222
1223 order = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *clip_len * sizeof(UINT));
1224 hr = ScriptStringGetOrder(ssa, order);
1225 ok(hr == S_OK, "ScriptStringGetOrder failed, got %08x, expected S_OK\n", hr);
1226
1227 for (i = 0; i < *clip_len; i++) ok(order[i] == i, "%d: got %d expected %d\n", i, order[i], i);
1228 HeapFree(GetProcessHeap(), 0, order);
1229
1230 hr = ScriptStringFree(&ssa);
1231 ok(hr == S_OK, "ScriptStringFree should return S_OK not %08x\n", hr);
1232 }
1233
1234 static void test_ScriptStringXtoCP_CPtoX(HDC hdc)
1235 {
1236 /*****************************************************************************************
1237 *
1238 * This test is for the ScriptStringXtoCP and ScriptStringXtoCP functions. Due to the
1239 * nature of the fonts between Windows and Wine, the test is implemented by generating
1240 * values using one one function then checking the output of the second. In this way
1241 * the validity of the functions is established using Windows as a base and confirming
1242 * similar behaviour in wine.
1243 */
1244
1245 HRESULT hr;
1246 WCHAR teststr1[] = {'T', 'e', 's', 't', 'e', 'a', 'b', ' ', 'a', '\0'};
1247 void *String = (WCHAR *) &teststr1; /* ScriptStringAnalysis needs void */
1248 int String_len = (sizeof(teststr1)/sizeof(WCHAR))-1;
1249 int Glyphs = String_len * 2 + 16; /* size of buffer as recommended */
1250 int Charset = -1; /* unicode */
1251 DWORD Flags = SSA_GLYPHS;
1252 int ReqWidth = 100;
1253 SCRIPT_CONTROL Control;
1254 SCRIPT_STATE State;
1255 SCRIPT_TABDEF Tabdef;
1256 const BYTE InClass = 0;
1257 SCRIPT_STRING_ANALYSIS ssa = NULL;
1258
1259 int Ch; /* Character position in string */
1260 int iTrailing;
1261 int Cp; /* Character position in string */
1262 int X;
1263 BOOL fTrailing;
1264
1265 /* Test with hdc, this should be a valid test
1266 * Here we generate an SCRIPT_STRING_ANALYSIS that will be used as input to the
1267 * following character positions to X and X to character position functions.
1268 */
1269 memset(&Control, 0, sizeof(SCRIPT_CONTROL));
1270 memset(&State, 0, sizeof(SCRIPT_STATE));
1271 memset(&Tabdef, 0, sizeof(SCRIPT_TABDEF));
1272
1273 hr = ScriptStringAnalyse( hdc, String, String_len, Glyphs, Charset, Flags,
1274 ReqWidth, &Control, &State, NULL, &Tabdef,
1275 &InClass, &ssa);
1276 ok(hr == S_OK ||
1277 hr == E_INVALIDARG, /* NT */
1278 "ScriptStringAnalyse should return S_OK or E_INVALIDARG not %08x\n", hr);
1279
1280 if (hr == S_OK)
1281 {
1282 ok(ssa != NULL, "ScriptStringAnalyse ssa should not be NULL\n");
1283
1284 /*
1285 * Loop to generate character positions to provide starting positions for the
1286 * ScriptStringCPtoX and ScriptStringXtoCP functions
1287 */
1288 for (Cp = 0; Cp < String_len; Cp++)
1289 {
1290 /* The fTrailing flag is used to indicate whether the X being returned is at
1291 * the beginning or the end of the character. What happens here is that if
1292 * fTrailing indicates the end of the character, ie. FALSE, then ScriptStringXtoCP
1293 * returns the beginning of the next character and iTrailing is FALSE. So for this
1294 * loop iTrailing will be FALSE in both cases.
1295 */
1296 fTrailing = FALSE;
1297 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
1298 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
1299 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
1300 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
1301 ok(Cp == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp, Ch, X);
1302 ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
1303 iTrailing, X);
1304 fTrailing = TRUE;
1305 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
1306 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
1307 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
1308 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
1309
1310 /*
1311 * Check that character position returned by ScriptStringXtoCP in Ch matches the
1312 * one input to ScriptStringCPtoX. This means that the Cp to X position and back
1313 * again works
1314 */
1315 ok(Cp + 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp + 1, Ch, X);
1316 ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
1317 iTrailing, X);
1318 }
1319 /*
1320 * This test is to check that if the X position is just inside the trailing edge of the
1321 * character then iTrailing will indicate the trailing edge, ie. TRUE
1322 */
1323 fTrailing = TRUE;
1324 Cp = 3;
1325 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
1326 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
1327 X--; /* put X just inside the trailing edge */
1328 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
1329 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
1330 ok(Cp == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp, Ch, X);
1331 ok(iTrailing == TRUE, "ScriptStringXtoCP should return iTrailing = 1 not %d for X = %d\n",
1332 iTrailing, X);
1333
1334 /*
1335 * This test is to check that if the X position is just outside the trailing edge of the
1336 * character then iTrailing will indicate the leading edge, ie. FALSE, and Ch will indicate
1337 * the next character, ie. Cp + 1
1338 */
1339 fTrailing = TRUE;
1340 Cp = 3;
1341 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
1342 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
1343 X++; /* put X just outside the trailing edge */
1344 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
1345 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
1346 ok(Cp + 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp + 1, Ch, X);
1347 ok(iTrailing == FALSE, "ScriptStringXtoCP should return iTrailing = 0 not %d for X = %d\n",
1348 iTrailing, X);
1349
1350 /*
1351 * This test is to check that if the X position is just outside the leading edge of the
1352 * character then iTrailing will indicate the trailing edge, ie. TRUE, and Ch will indicate
1353 * the next character down , ie. Cp - 1
1354 */
1355 fTrailing = FALSE;
1356 Cp = 3;
1357 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
1358 ok(hr == S_OK, "ScriptStringCPtoX should return S_OK not %08x\n", hr);
1359 X--; /* put X just outside the leading edge */
1360 hr = ScriptStringXtoCP(ssa, X, &Ch, &iTrailing);
1361 ok(hr == S_OK, "ScriptStringXtoCP should return S_OK not %08x\n", hr);
1362 ok(Cp - 1 == Ch, "ScriptStringXtoCP should return Ch = %d not %d for X = %d\n", Cp - 1, Ch, X);
1363 ok(iTrailing == TRUE, "ScriptStringXtoCP should return iTrailing = 1 not %d for X = %d\n",
1364 iTrailing, X);
1365
1366 /*
1367 * Cleanup the SSA for the next round of tests
1368 */
1369 hr = ScriptStringFree(&ssa);
1370 ok(hr == S_OK, "ScriptStringFree should return S_OK not %08x\n", hr);
1371
1372 /*
1373 * Test to see that exceeding the number of chars returns E_INVALIDARG. First
1374 * generate an SSA for the subsequent tests.
1375 */
1376 hr = ScriptStringAnalyse( hdc, String, String_len, Glyphs, Charset, Flags,
1377 ReqWidth, &Control, &State, NULL, &Tabdef,
1378 &InClass, &ssa);
1379 ok(hr == S_OK, "ScriptStringAnalyse should return S_OK not %08x\n", hr);
1380
1381 /*
1382 * When ScriptStringCPtoX is called with a character position Cp that exceeds the
1383 * string length, return E_INVALIDARG. This also invalidates the ssa so a
1384 * ScriptStringFree should also fail.
1385 */
1386 fTrailing = FALSE;
1387 Cp = String_len + 1;
1388 hr = ScriptStringCPtoX(ssa, Cp, fTrailing, &X);
1389 ok(hr == E_INVALIDARG, "ScriptStringCPtoX should return E_INVALIDARG not %08x\n", hr);
1390
1391 ScriptStringFree(&ssa);
1392 }
1393 }
1394
1395 static void test_ScriptCacheGetHeight(HDC hdc)
1396 {
1397 HRESULT hr;
1398 SCRIPT_CACHE sc = NULL;
1399 LONG height;
1400
1401 hr = ScriptCacheGetHeight(NULL, NULL, NULL);
1402 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1403
1404 hr = ScriptCacheGetHeight(NULL, &sc, NULL);
1405 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1406
1407 hr = ScriptCacheGetHeight(NULL, &sc, &height);
1408 ok(hr == E_PENDING, "expected E_PENDING, got 0x%08x\n", hr);
1409
1410 height = 0;
1411
1412 hr = ScriptCacheGetHeight(hdc, &sc, &height);
1413 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1414 ok(height > 0, "expected height > 0\n");
1415
1416 ScriptFreeCache(&sc);
1417 }
1418
1419 static void test_ScriptGetGlyphABCWidth(HDC hdc)
1420 {
1421 HRESULT hr;
1422 SCRIPT_CACHE sc = NULL;
1423 ABC abc;
1424
1425 hr = ScriptGetGlyphABCWidth(NULL, NULL, 'a', NULL);
1426 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1427
1428 hr = ScriptGetGlyphABCWidth(NULL, &sc, 'a', NULL);
1429 ok(broken(hr == E_PENDING) ||
1430 hr == E_INVALIDARG, /* WIN7 */
1431 "expected E_INVALIDARG, got 0x%08x\n", hr);
1432
1433 hr = ScriptGetGlyphABCWidth(NULL, &sc, 'a', &abc);
1434 ok(hr == E_PENDING, "expected E_PENDING, got 0x%08x\n", hr);
1435
1436 if (0) { /* crashes on WinXP */
1437 hr = ScriptGetGlyphABCWidth(hdc, &sc, 'a', NULL);
1438 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1439 }
1440
1441 hr = ScriptGetGlyphABCWidth(hdc, &sc, 'a', &abc);
1442 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1443
1444 ScriptFreeCache(&sc);
1445 }
1446
1447 static void test_ScriptLayout(void)
1448 {
1449 HRESULT hr;
1450 static const BYTE levels[][10] =
1451 {
1452 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
1453 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
1454 { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
1455 { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
1456
1457 { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1},
1458 { 1, 1, 1, 2, 2, 2, 1, 1, 1, 1 },
1459 { 2, 2, 2, 1, 1, 1, 2, 2, 2, 2 },
1460 { 0, 0, 1, 1, 2, 2, 1, 1, 0, 0 },
1461 { 1, 1, 2, 2, 3, 3, 2, 2, 1, 1 },
1462
1463 { 0, 0, 1, 1, 2, 2, 1, 1, 0, 1 },
1464 { 1, 0, 1, 2, 2, 1, 2, 1, 0, 1 },
1465 };
1466 static const int expect_l2v[][10] =
1467 {
1468 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
1469 { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
1470 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
1471 { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
1472
1473 { 0, 1, 2, 3, 4, 9, 8 ,7 ,6, 5},
1474 /**/ { 9, 8, 7, 4, 5, 6, 3 ,2 ,1, 0},
1475 /**/ { 7, 8, 9, 6, 5, 4, 0 ,1 ,2, 3},
1476 { 0, 1, 7, 6, 4, 5, 3 ,2 ,8, 9},
1477 { 9, 8, 2, 3, 5, 4, 6 ,7 ,1, 0},
1478
1479 { 0, 1, 7, 6, 4, 5, 3 ,2 ,8, 9},
1480 /**/ { 0, 1, 7, 5, 6, 4, 3 ,2 ,8, 9},
1481 };
1482 static const int expect_v2l[][10] =
1483 {
1484 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
1485 { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
1486 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
1487 { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 },
1488
1489 { 0, 1, 2, 3, 4, 9, 8 ,7 ,6, 5},
1490 { 9, 8, 7, 6, 3, 4, 5 ,2 ,1, 0},
1491 { 6, 7, 8, 9, 5, 4, 3 ,0 ,1, 2},
1492 { 0, 1, 7, 6, 4, 5, 3 ,2 ,8, 9},
1493 { 9, 8, 2, 3, 5, 4, 6 ,7 ,1, 0},
1494
1495 { 0, 1, 7, 6, 4, 5, 3 ,2 ,8, 9},
1496 { 0, 1, 7, 6, 5, 3, 4 ,2 ,8, 9},
1497 };
1498
1499 int i, j, vistolog[sizeof(levels[0])], logtovis[sizeof(levels[0])];
1500
1501 hr = ScriptLayout(sizeof(levels[0]), NULL, vistolog, logtovis);
1502 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1503
1504 hr = ScriptLayout(sizeof(levels[0]), levels[0], NULL, NULL);
1505 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got 0x%08x\n", hr);
1506
1507 for (i = 0; i < sizeof(levels)/sizeof(levels[0]); i++)
1508 {
1509 hr = ScriptLayout(sizeof(levels[0]), levels[i], vistolog, logtovis);
1510 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1511
1512 for (j = 0; j < sizeof(levels[i]); j++)
1513 {
1514 ok(expect_v2l[i][j] == vistolog[j],
1515 "failure: levels[%d][%d] = %d, vistolog[%d] = %d\n",
1516 i, j, levels[i][j], j, vistolog[j] );
1517 }
1518
1519 for (j = 0; j < sizeof(levels[i]); j++)
1520 {
1521 ok(expect_l2v[i][j] == logtovis[j],
1522 "failure: levels[%d][%d] = %d, logtovis[%d] = %d\n",
1523 i, j, levels[i][j], j, logtovis[j] );
1524 }
1525 }
1526 }
1527
1528 static BOOL CALLBACK enum_proc(LGRPID group, LCID lcid, LPSTR locale, LONG_PTR lparam)
1529 {
1530 HRESULT hr;
1531 SCRIPT_DIGITSUBSTITUTE sds;
1532 SCRIPT_CONTROL sc;
1533 SCRIPT_STATE ss;
1534 LCID lcid_old;
1535
1536 if (!IsValidLocale(lcid, LCID_INSTALLED)) return TRUE;
1537
1538 memset(&sds, 0, sizeof(sds));
1539 memset(&sc, 0, sizeof(sc));
1540 memset(&ss, 0, sizeof(ss));
1541
1542 lcid_old = GetThreadLocale();
1543 if (!SetThreadLocale(lcid)) return TRUE;
1544
1545 hr = ScriptRecordDigitSubstitution(lcid, &sds);
1546 ok(hr == S_OK, "ScriptRecordDigitSubstitution failed: 0x%08x\n", hr);
1547
1548 hr = ScriptApplyDigitSubstitution(&sds, &sc, &ss);
1549 ok(hr == S_OK, "ScriptApplyDigitSubstitution failed: 0x%08x\n", hr);
1550
1551 SetThreadLocale(lcid_old);
1552 return TRUE;
1553 }
1554
1555 static void test_digit_substitution(void)
1556 {
1557 BOOL ret;
1558 unsigned int i;
1559 static const LGRPID groups[] =
1560 {
1561 LGRPID_WESTERN_EUROPE,
1562 LGRPID_CENTRAL_EUROPE,
1563 LGRPID_BALTIC,
1564 LGRPID_GREEK,
1565 LGRPID_CYRILLIC,
1566 LGRPID_TURKISH,
1567 LGRPID_JAPANESE,
1568 LGRPID_KOREAN,
1569 LGRPID_TRADITIONAL_CHINESE,
1570 LGRPID_SIMPLIFIED_CHINESE,
1571 LGRPID_THAI,
1572 LGRPID_HEBREW,
1573 LGRPID_ARABIC,
1574 LGRPID_VIETNAMESE,
1575 LGRPID_INDIC,
1576 LGRPID_GEORGIAN,
1577 LGRPID_ARMENIAN
1578 };
1579 HMODULE hKernel32;
1580 static BOOL (WINAPI * pEnumLanguageGroupLocalesA)(LANGGROUPLOCALE_ENUMPROCA,LGRPID,DWORD,LONG_PTR);
1581
1582 hKernel32 = GetModuleHandleA("kernel32.dll");
1583 pEnumLanguageGroupLocalesA = (void*)GetProcAddress(hKernel32, "EnumLanguageGroupLocalesA");
1584
1585 if (!pEnumLanguageGroupLocalesA)
1586 {
1587 win_skip("EnumLanguageGroupLocalesA not available on this platform\n");
1588 return;
1589 }
1590
1591 for (i = 0; i < sizeof(groups)/sizeof(groups[0]); i++)
1592 {
1593 ret = pEnumLanguageGroupLocalesA(enum_proc, groups[i], 0, 0);
1594 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1595 {
1596 win_skip("EnumLanguageGroupLocalesA not implemented on this platform\n");
1597 break;
1598 }
1599
1600 ok(ret, "EnumLanguageGroupLocalesA failed unexpectedly: %u\n", GetLastError());
1601 }
1602 }
1603
1604 static void test_ScriptGetProperties(void)
1605 {
1606 const SCRIPT_PROPERTIES **props;
1607 HRESULT hr;
1608 int num;
1609
1610 hr = ScriptGetProperties(NULL, NULL);
1611 ok(hr == E_INVALIDARG, "ScriptGetProperties succeeded\n");
1612
1613 hr = ScriptGetProperties(NULL, &num);
1614 ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1615
1616 hr = ScriptGetProperties(&props, NULL);
1617 ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1618
1619 hr = ScriptGetProperties(&props, &num);
1620 ok(hr == S_OK, "ScriptGetProperties failed: 0x%08x\n", hr);
1621 }
1622
1623 static void test_ScriptBreak(void)
1624 {
1625 static const WCHAR test[] = {' ','\r','\n',0};
1626 SCRIPT_ITEM items[4];
1627 SCRIPT_LOGATTR la;
1628 HRESULT hr;
1629
1630 hr = ScriptItemize(test, 3, 4, NULL, NULL, items, NULL);
1631 ok(!hr, "ScriptItemize should return S_OK not %08x\n", hr);
1632
1633 memset(&la, 0, sizeof(la));
1634 hr = ScriptBreak(test, 1, &items[0].a, &la);
1635 ok(!hr, "ScriptBreak should return S_OK not %08x\n", hr);
1636
1637 ok(!la.fSoftBreak, "fSoftBreak set\n");
1638 ok(la.fWhiteSpace, "fWhiteSpace not set\n");
1639 ok(la.fCharStop, "fCharStop not set\n");
1640 ok(!la.fWordStop, "fWordStop set\n");
1641 ok(!la.fInvalid, "fInvalid set\n");
1642 ok(!la.fReserved, "fReserved set\n");
1643
1644 memset(&la, 0, sizeof(la));
1645 hr = ScriptBreak(test + 1, 1, &items[1].a, &la);
1646 ok(!hr, "ScriptBreak should return S_OK not %08x\n", hr);
1647
1648 ok(!la.fSoftBreak, "fSoftBreak set\n");
1649 ok(!la.fWhiteSpace, "fWhiteSpace set\n");
1650 ok(la.fCharStop, "fCharStop not set\n");
1651 ok(!la.fWordStop, "fWordStop set\n");
1652 ok(!la.fInvalid, "fInvalid set\n");
1653 ok(!la.fReserved, "fReserved set\n");
1654
1655 memset(&la, 0, sizeof(la));
1656 hr = ScriptBreak(test + 2, 1, &items[2].a, &la);
1657 ok(!hr, "ScriptBreak should return S_OK not %08x\n", hr);
1658
1659 ok(!la.fSoftBreak, "fSoftBreak set\n");
1660 ok(!la.fWhiteSpace, "fWhiteSpace set\n");
1661 ok(la.fCharStop, "fCharStop not set\n");
1662 ok(!la.fWordStop, "fWordStop set\n");
1663 ok(!la.fInvalid, "fInvalid set\n");
1664 ok(!la.fReserved, "fReserved set\n");
1665 }
1666
1667 static void test_newlines(void)
1668 {
1669 static const WCHAR test1[] = {'t','e','x','t','\r','t','e','x','t',0};
1670 static const WCHAR test2[] = {'t','e','x','t','\n','t','e','x','t',0};
1671 static const WCHAR test3[] = {'t','e','x','t','\r','\n','t','e','x','t',0};
1672 static const WCHAR test4[] = {'t','e','x','t','\n','\r','t','e','x','t',0};
1673 static const WCHAR test5[] = {'1','2','3','4','\n','\r','1','2','3','4',0};
1674 SCRIPT_ITEM items[5];
1675 HRESULT hr;
1676 int count;
1677
1678 count = 0;
1679 hr = ScriptItemize(test1, lstrlenW(test1), 5, NULL, NULL, items, &count);
1680 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1681 ok(count == 3, "got %d expected 3\n", count);
1682
1683 count = 0;
1684 hr = ScriptItemize(test2, lstrlenW(test2), 5, NULL, NULL, items, &count);
1685 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1686 ok(count == 3, "got %d expected 3\n", count);
1687
1688 count = 0;
1689 hr = ScriptItemize(test3, lstrlenW(test3), 5, NULL, NULL, items, &count);
1690 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1691 ok(count == 4, "got %d expected 4\n", count);
1692
1693 count = 0;
1694 hr = ScriptItemize(test4, lstrlenW(test4), 5, NULL, NULL, items, &count);
1695 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1696 ok(count == 4, "got %d expected 4\n", count);
1697
1698 count = 0;
1699 hr = ScriptItemize(test5, lstrlenW(test5), 5, NULL, NULL, items, &count);
1700 ok(hr == S_OK, "ScriptItemize failed: 0x%08x\n", hr);
1701 ok(count == 4, "got %d expected 4\n", count);
1702 }
1703
1704 START_TEST(usp10)
1705 {
1706 HWND hwnd;
1707 HDC hdc;
1708 LOGFONTA lf;
1709 HFONT hfont;
1710
1711 unsigned short pwOutGlyphs[256];
1712
1713 /* We need a valid HDC to drive a lot of Script functions which requires the following *
1714 * to set up for the tests. */
1715 hwnd = CreateWindowExA(0, "static", "", WS_POPUP, 0,0,100,100,
1716 0, 0, 0, NULL);
1717 assert(hwnd != 0);
1718 ShowWindow(hwnd, SW_SHOW);
1719 UpdateWindow(hwnd);
1720
1721 hdc = GetDC(hwnd); /* We now have a hdc */
1722 ok( hdc != NULL, "HDC failed to be created %p\n", hdc);
1723
1724 memset(&lf, 0, sizeof(LOGFONTA));
1725 lstrcpyA(lf.lfFaceName, "Tahoma");
1726 lf.lfHeight = 10;
1727 lf.lfWeight = 3;
1728 lf.lfWidth = 10;
1729
1730 hfont = SelectObject(hdc, CreateFontIndirectA(&lf));
1731 ok(hfont != NULL, "SelectObject failed: %p\n", hfont);
1732
1733 test_ScriptItemize();
1734 test_ScriptItemIzeShapePlace(hdc,pwOutGlyphs);
1735 test_ScriptGetCMap(hdc, pwOutGlyphs);
1736 test_ScriptCacheGetHeight(hdc);
1737 test_ScriptGetGlyphABCWidth(hdc);
1738 test_ScriptShape(hdc);
1739 test_ScriptPlace(hdc);
1740
1741 test_ScriptGetFontProperties(hdc);
1742 test_ScriptTextOut(hdc);
1743 test_ScriptTextOut2(hdc);
1744 test_ScriptTextOut3(hdc);
1745 test_ScriptXtoX();
1746 test_ScriptString(hdc);
1747 test_ScriptStringXtoCP_CPtoX(hdc);
1748
1749 test_ScriptLayout();
1750 test_digit_substitution();
1751 test_ScriptGetProperties();
1752 test_ScriptBreak();
1753 test_newlines();
1754
1755 ReleaseDC(hwnd, hdc);
1756 DestroyWindow(hwnd);
1757 }
useful hacks and other patches not (yet) suitable for mainline