ReactOS 0.4.16-dev-2332-g4cba65d
Functions
GetCharWidth.c File Reference
#include "precomp.h"
Include dependency graph for GetCharWidth.c:

Go to the source code of this file.

Functions

static void Test_CharWidthA (HDC hDC)
 
static void Test_CharWidthW (HDC hDC)
 
static void Test_CharWidthI (HDC hDC)
 
static void Test_CharWidth32A (HDC hDC)
 
static void Test_CharWidth32W (HDC hDC)
 
static void Test_CharWidthFloatA (HDC hDC)
 
static void Test_CharWidthFloatW (HDC hDC)
 
 START_TEST (GetCharWidth)
 

Function Documentation

◆ START_TEST()

START_TEST ( GetCharWidth  )

Definition at line 349 of file GetCharWidth.c.

350{
351 HDC hDC = CreateCompatibleDC(NULL);
352 Test_CharWidthA(hDC);
353 Test_CharWidthW(hDC);
354 Test_CharWidthI(hDC);
355 Test_CharWidth32A(hDC);
356 Test_CharWidth32W(hDC);
357 Test_CharWidthFloatA(hDC);
358 Test_CharWidthFloatW(hDC);
359 DeleteDC(hDC);
360}
hDC
static HDC hDC
Definition: 3dtext.c:33
Test_CharWidthW
static void Test_CharWidthW(HDC hDC)
Definition: GetCharWidth.c:56
Test_CharWidthA
static void Test_CharWidthA(HDC hDC)
Definition: GetCharWidth.c:10
Test_CharWidthFloatA
static void Test_CharWidthFloatA(HDC hDC)
Definition: GetCharWidth.c:257
Test_CharWidth32A
static void Test_CharWidth32A(HDC hDC)
Definition: GetCharWidth.c:165
Test_CharWidthI
static void Test_CharWidthI(HDC hDC)
Definition: GetCharWidth.c:102
Test_CharWidth32W
static void Test_CharWidth32W(HDC hDC)
Definition: GetCharWidth.c:211
Test_CharWidthFloatW
static void Test_CharWidthFloatW(HDC hDC)
Definition: GetCharWidth.c:303
NULL
#define NULL
Definition: types.h:112
HDC
static HDC
Definition: imagelist.c:88
CreateCompatibleDC
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
DeleteDC
BOOL WINAPI DeleteDC(_In_ HDC)

◆ Test_CharWidth32A()

static void Test_CharWidth32A ( HDC  hDC)
static

Definition at line 165 of file GetCharWidth.c.

166{
167 BOOL ret;
168 INT anBuffer['Z' - 'A' + 1];
169
170 SetLastError(0xBEEFCAFE);
171 ret = GetCharWidth32A(NULL, 'A', 'Z', NULL);
172 ok_int(ret, FALSE);
173 ok_err(ERROR_INVALID_PARAMETER);
174
175 SetLastError(0xBEEFCAFE);
176 ret = GetCharWidth32A(NULL, 'B', 'A', NULL);
177 ok_int(ret, FALSE);
178 ok_err(ERROR_INVALID_PARAMETER);
179
180 SetLastError(0xBEEFCAFE);
181 ret = GetCharWidth32A(NULL, 'A', 'Z', anBuffer);
182 ok_int(ret, FALSE);
183 ok_err(ERROR_INVALID_PARAMETER);
184
185 SetLastError(0xBEEFCAFE);
186 ret = GetCharWidth32A(NULL, 'B', 'A', anBuffer);
187 ok_int(ret, FALSE);
188 ok_err(ERROR_INVALID_PARAMETER);
189
190 SetLastError(0xBEEFCAFE);
191 ret = GetCharWidth32A(hDC, 'A', 'Z', NULL);
192 ok_int(ret, FALSE);
193 ok_err(ERROR_INVALID_PARAMETER); //
194
195 SetLastError(0xBEEFCAFE);
196 ret = GetCharWidth32A(hDC, 'B', 'A', NULL);
197 ok_int(ret, FALSE);
198 ok_err(ERROR_INVALID_PARAMETER); //
199
200 SetLastError(0xBEEFCAFE);
201 ret = GetCharWidth32A(hDC, 'A', 'Z', anBuffer);
202 ok_int(ret, TRUE);
203 ok_err(0xBEEFCAFE);
204
205 SetLastError(0xBEEFCAFE);
206 ret = GetCharWidth32A(hDC, 'A', 'B', anBuffer);
207 ok_int(ret, TRUE);
208 ok_err(0xBEEFCAFE);
209}
ok_err
#define ok_err(error)
Definition: atltest.h:124
ok_int
#define ok_int(expression, result)
Definition: atltest.h:134
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
SetLastError
#define SetLastError(x)
Definition: compat.h:752
ret
return ret
Definition: mutex.c:146
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
INT
int32_t INT
Definition: typedefs.h:58
GetCharWidth32A
BOOL WINAPI GetCharWidth32A(_In_ HDC hdc, _In_ UINT iFirst, _In_ UINT iLast, _Out_writes_(iLast+1 - iFirst) LPINT lpBuffer)

Referenced by START_TEST().

◆ Test_CharWidth32W()

static void Test_CharWidth32W ( HDC  hDC)
static

Definition at line 211 of file GetCharWidth.c.

212{
213 BOOL ret;
214 INT anBuffer['Z' - 'A' + 1];
215
216 SetLastError(0xBEEFCAFE);
217 ret = GetCharWidth32W(NULL, 'A', 'Z', NULL);
218 ok_int(ret, FALSE);
219 ok_err(ERROR_INVALID_PARAMETER);
220
221 SetLastError(0xBEEFCAFE);
222 ret = GetCharWidth32W(NULL, 'B', 'A', NULL);
223 ok_int(ret, FALSE);
224 ok_err(ERROR_INVALID_PARAMETER);
225
226 SetLastError(0xBEEFCAFE);
227 ret = GetCharWidth32W(NULL, 'A', 'Z', anBuffer);
228 ok_int(ret, FALSE);
229 ok_err(ERROR_INVALID_PARAMETER);
230
231 SetLastError(0xBEEFCAFE);
232 ret = GetCharWidth32W(NULL, 'B', 'A', anBuffer);
233 ok_int(ret, FALSE);
234 ok_err(ERROR_INVALID_PARAMETER);
235
236 SetLastError(0xBEEFCAFE);
237 ret = GetCharWidth32W(hDC, 'A', 'Z', NULL);
238 ok_int(ret, FALSE);
239 ok_err(ERROR_INVALID_PARAMETER);
240
241 SetLastError(0xBEEFCAFE);
242 ret = GetCharWidth32W(hDC, 'B', 'A', NULL);
243 ok_int(ret, FALSE);
244 ok_err(ERROR_INVALID_PARAMETER);
245
246 SetLastError(0xBEEFCAFE);
247 ret = GetCharWidth32W(hDC, 'A', 'Z', anBuffer);
248 ok_int(ret, TRUE);
249 ok_err(0xBEEFCAFE);
250
251 SetLastError(0xBEEFCAFE);
252 ret = GetCharWidth32W(hDC, 'A', 'B', anBuffer);
253 ok_int(ret, TRUE);
254 ok_err(0xBEEFCAFE);
255}
GetCharWidth32W
BOOL WINAPI GetCharWidth32W(_In_ HDC hdc, _In_ UINT iFirst, _In_ UINT iLast, _Out_writes_(iLast+1 - iFirst) LPINT lpBuffer)

Referenced by START_TEST().

◆ Test_CharWidthA()

static void Test_CharWidthA ( HDC  hDC)
static

Definition at line 10 of file GetCharWidth.c.

11{
12 BOOL ret;
13 INT anBuffer['Z' - 'A' + 1];
14
15 SetLastError(0xBEEFCAFE);
16 ret = GetCharWidthA(NULL, 'A', 'Z', NULL);
17 ok_int(ret, FALSE);
18 ok_err(ERROR_INVALID_PARAMETER);
19
20 SetLastError(0xBEEFCAFE);
21 ret = GetCharWidthA(NULL, 'B', 'A', NULL);
22 ok_int(ret, FALSE);
23 ok_err(ERROR_INVALID_PARAMETER);
24
25 SetLastError(0xBEEFCAFE);
26 ret = GetCharWidthA(NULL, 'A', 'Z', anBuffer);
27 ok_int(ret, FALSE);
28 ok_err(ERROR_INVALID_PARAMETER);
29
30 SetLastError(0xBEEFCAFE);
31 ret = GetCharWidthA(NULL, 'B', 'A', anBuffer);
32 ok_int(ret, FALSE);
33 ok_err(ERROR_INVALID_PARAMETER);
34
35 SetLastError(0xBEEFCAFE);
36 ret = GetCharWidthA(hDC, 'A', 'Z', NULL);
37 ok_int(ret, FALSE);
38 ok_err(ERROR_INVALID_PARAMETER); //
39
40 SetLastError(0xBEEFCAFE);
41 ret = GetCharWidthA(hDC, 'B', 'A', NULL);
42 ok_int(ret, FALSE);
43 ok_err(ERROR_INVALID_PARAMETER); //
44
45 SetLastError(0xBEEFCAFE);
46 ret = GetCharWidthA(hDC, 'A', 'Z', anBuffer);
47 ok_int(ret, TRUE);
48 ok_err(0xBEEFCAFE);
49
50 SetLastError(0xBEEFCAFE);
51 ret = GetCharWidthA(hDC, 'A', 'B', anBuffer);
52 ok_int(ret, TRUE);
53 ok_err(0xBEEFCAFE);
54}
GetCharWidthA
BOOL WINAPI GetCharWidthA(_In_ HDC hdc, _In_ UINT iFirst, _In_ UINT iLast, _Out_writes_(iLast+1 - iFirst) LPINT lpBuffer)

Referenced by START_TEST().

◆ Test_CharWidthFloatA()

static void Test_CharWidthFloatA ( HDC  hDC)
static

Definition at line 257 of file GetCharWidth.c.

258{
259 BOOL ret;
260 FLOAT aeBuffer['Z' - 'A' + 1];
261
262 SetLastError(0xBEEFCAFE);
263 ret = GetCharWidthFloatA(NULL, 'A', 'Z', NULL);
264 ok_int(ret, FALSE);
265 ok_err(ERROR_INVALID_PARAMETER);
266
267 SetLastError(0xBEEFCAFE);
268 ret = GetCharWidthFloatA(NULL, 'B', 'A', NULL);
269 ok_int(ret, FALSE);
270 ok_err(ERROR_INVALID_PARAMETER);
271
272 SetLastError(0xBEEFCAFE);
273 ret = GetCharWidthFloatA(NULL, 'A', 'Z', aeBuffer);
274 ok_int(ret, FALSE);
275 ok_err(ERROR_INVALID_PARAMETER);
276
277 SetLastError(0xBEEFCAFE);
278 ret = GetCharWidthFloatA(NULL, 'B', 'A', aeBuffer);
279 ok_int(ret, FALSE);
280 ok_err(ERROR_INVALID_PARAMETER);
281
282 SetLastError(0xBEEFCAFE);
283 ret = GetCharWidthFloatA(hDC, 'A', 'Z', NULL);
284 ok_int(ret, FALSE);
285 ok_err(ERROR_INVALID_PARAMETER); //
286
287 SetLastError(0xBEEFCAFE);
288 ret = GetCharWidthFloatA(hDC, 'B', 'A', NULL);
289 ok_int(ret, FALSE);
290 ok_err(ERROR_INVALID_PARAMETER); //
291
292 SetLastError(0xBEEFCAFE);
293 ret = GetCharWidthFloatA(hDC, 'A', 'Z', aeBuffer);
294 ok_int(ret, TRUE);
295 ok_err(0xBEEFCAFE);
296
297 SetLastError(0xBEEFCAFE);
298 ret = GetCharWidthFloatA(hDC, 'A', 'B', aeBuffer);
299 ok_int(ret, TRUE);
300 ok_err(0xBEEFCAFE);
301}
FLOAT
float FLOAT
Definition: typedefs.h:69
GetCharWidthFloatA
BOOL WINAPI GetCharWidthFloatA(_In_ HDC hdc, _In_ UINT iFirst, _In_ UINT iLast, _Out_writes_(iLast+1 - iFirst) PFLOAT lpBuffer)

Referenced by START_TEST().

◆ Test_CharWidthFloatW()

static void Test_CharWidthFloatW ( HDC  hDC)
static

Definition at line 303 of file GetCharWidth.c.

304{
305 BOOL ret;
306 FLOAT aeBuffer['Z' - 'A' + 1];
307
308 SetLastError(0xBEEFCAFE);
309 ret = GetCharWidthFloatW(NULL, 'A', 'Z', NULL);
310 ok_int(ret, FALSE);
311 ok_err(ERROR_INVALID_PARAMETER);
312
313 SetLastError(0xBEEFCAFE);
314 ret = GetCharWidthFloatW(NULL, 'B', 'A', NULL);
315 ok_int(ret, FALSE);
316 ok_err(ERROR_INVALID_PARAMETER);
317
318 SetLastError(0xBEEFCAFE);
319 ret = GetCharWidthFloatW(NULL, 'A', 'Z', aeBuffer);
320 ok_int(ret, FALSE);
321 ok_err(ERROR_INVALID_PARAMETER);
322
323 SetLastError(0xBEEFCAFE);
324 ret = GetCharWidthFloatW(NULL, 'B', 'A', aeBuffer);
325 ok_int(ret, FALSE);
326 ok_err(ERROR_INVALID_PARAMETER);
327
328 SetLastError(0xBEEFCAFE);
329 ret = GetCharWidthFloatW(hDC, 'A', 'Z', NULL);
330 ok_int(ret, FALSE);
331 ok_err(ERROR_INVALID_PARAMETER);
332
333 SetLastError(0xBEEFCAFE);
334 ret = GetCharWidthFloatW(hDC, 'B', 'A', NULL);
335 ok_int(ret, FALSE);
336 ok_err(ERROR_INVALID_PARAMETER);
337
338 SetLastError(0xBEEFCAFE);
339 ret = GetCharWidthFloatW(hDC, 'A', 'Z', aeBuffer);
340 ok_int(ret, TRUE);
341 ok_err(0xBEEFCAFE);
342
343 SetLastError(0xBEEFCAFE);
344 ret = GetCharWidthFloatW(hDC, 'A', 'B', aeBuffer);
345 ok_int(ret, TRUE);
346 ok_err(0xBEEFCAFE);
347}
GetCharWidthFloatW
BOOL WINAPI GetCharWidthFloatW(_In_ HDC hdc, _In_ UINT iFirst, _In_ UINT iLast, _Out_writes_(iLast+1 - iFirst) PFLOAT lpBuffer)

Referenced by START_TEST().

◆ Test_CharWidthI()

static void Test_CharWidthI ( HDC  hDC)
static

Definition at line 102 of file GetCharWidth.c.

103{
104 BOOL ret;
105 WORD awBuffer['Z' - 'A' + 1];
106 INT anWidths['Z' - 'A' + 1];
107
108 SetLastError(0xBEEFCAFE);
109 ret = GetCharWidthI(NULL, 0, 0, NULL, NULL);
110 ok_int(ret, FALSE);
111 ok_err(ERROR_INVALID_PARAMETER);
112
113 SetLastError(0xBEEFCAFE);
114 ret = GetCharWidthI(hDC, 0, 0, NULL, NULL);
115 ok_int(ret, FALSE);
116 ok_err(ERROR_INVALID_PARAMETER);
117
118 SetLastError(0xBEEFCAFE);
119 ret = GetCharWidthI(NULL, 0, 1, awBuffer, anWidths);
120 ok_int(ret, FALSE);
121 ok_err(ERROR_INVALID_HANDLE);
122
123 SetLastError(0xBEEFCAFE);
124 ret = GetCharWidthI(hDC, 0, 1, awBuffer, NULL);
125 ok_int(ret, FALSE);
126 ok_err(ERROR_INVALID_PARAMETER);
127
128 SetLastError(0xBEEFCAFE);
129 ret = GetCharWidthI(hDC, 0, 1, awBuffer, anWidths);
130 ok_int(ret, TRUE);
131 ok_err(0xBEEFCAFE);
132
133 SetLastError(0xBEEFCAFE);
134 ret = GetCharWidthI(hDC, 0, _countof(awBuffer), awBuffer, anWidths);
135 ok_int(ret, TRUE);
136 ok_err(0xBEEFCAFE);
137
138#if 0 // These tests take time in ReactOS
139 INT count = 0x2710000 / sizeof(INT);
140 PINT pn = malloc((count + 1) * sizeof(INT));
141 PWORD pw = malloc((count + 1) * sizeof(WORD));
142
143 if (!pn || !pw)
144 {
145 skip("allocation failed\n");
146 }
147 else
148 {
149 SetLastError(0xBEEFCAFE);
150 ret = GetCharWidthI(hDC, 0, count, pw, pn);
151 ok_int(ret, TRUE);
152 ok_err(0xBEEFCAFE);
153
154 SetLastError(0xBEEFCAFE);
155 ret = GetCharWidthI(hDC, 0, count + 1, pw, pn);
156 ok_int(ret, FALSE);
157 ok_err(0xBEEFCAFE);
158 }
159
160 free(pn);
161 free(pw);
162#endif
163}
skip
#define skip(...)
Definition: atltest.h:64
free
#define free
Definition: debug_ros.c:5
malloc
#define malloc
Definition: debug_ros.c:4
ERROR_INVALID_HANDLE
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
PINT
int * PINT
Definition: minwindef.h:150
pn
static int pints_t pn[]
Definition: server.c:148
PWORD
WORD * PWORD
Definition: pedump.c:67
INT
#define INT
Definition: polytest.cpp:20
_countof
#define _countof(array)
Definition: sndvol32.h:70
GetCharWidthI
BOOL WINAPI GetCharWidthI(_In_ HDC hdc, _In_ UINT giFirst, _In_ UINT cgi, _In_reads_opt_(cgi) LPWORD pgi, _Out_writes_(cgi) LPINT piWidths)

Referenced by START_TEST().

◆ Test_CharWidthW()

static void Test_CharWidthW ( HDC  hDC)
static

Definition at line 56 of file GetCharWidth.c.

57{
58 BOOL ret;
59 INT anBuffer['Z' - 'A' + 1];
60
61 SetLastError(0xBEEFCAFE);
62 ret = GetCharWidthW(NULL, 'A', 'Z', NULL);
63 ok_int(ret, FALSE);
64 ok_err(ERROR_INVALID_PARAMETER);
65
66 SetLastError(0xBEEFCAFE);
67 ret = GetCharWidthW(NULL, 'B', 'A', NULL);
68 ok_int(ret, FALSE);
69 ok_err(ERROR_INVALID_PARAMETER);
70
71 SetLastError(0xBEEFCAFE);
72 ret = GetCharWidthW(NULL, 'A', 'Z', anBuffer);
73 ok_int(ret, FALSE);
74 ok_err(ERROR_INVALID_PARAMETER);
75
76 SetLastError(0xBEEFCAFE);
77 ret = GetCharWidthW(NULL, 'B', 'A', anBuffer);
78 ok_int(ret, FALSE);
79 ok_err(ERROR_INVALID_PARAMETER);
80
81 SetLastError(0xBEEFCAFE);
82 ret = GetCharWidthW(hDC, 'A', 'Z', NULL);
83 ok_int(ret, FALSE);
84 ok_err(ERROR_INVALID_PARAMETER);
85
86 SetLastError(0xBEEFCAFE);
87 ret = GetCharWidthW(hDC, 'B', 'A', NULL);
88 ok_int(ret, FALSE);
89 ok_err(ERROR_INVALID_PARAMETER);
90
91 SetLastError(0xBEEFCAFE);
92 ret = GetCharWidthW(hDC, 'A', 'Z', anBuffer);
93 ok_int(ret, TRUE);
94 ok_err(0xBEEFCAFE);
95
96 SetLastError(0xBEEFCAFE);
97 ret = GetCharWidthW(hDC, 'A', 'B', anBuffer);
98 ok_int(ret, TRUE);
99 ok_err(0xBEEFCAFE);
100}
GetCharWidthW
BOOL WINAPI GetCharWidthW(_In_ HDC hdc, _In_ UINT iFirst, _In_ UINT iLast, _Out_writes_(iLast+1 - iFirst) LPINT lpBuffer)

Referenced by START_TEST().