ReactOS 0.4.17-dev-116-ga4b6fe9
env.c
Go to the documentation of this file.
1/*
2 * Unit test suite for ntdll env functions
3 *
4 * Copyright 2003 Eric Pouech
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21#include <stdio.h>
22#include <stdarg.h>
23
24#include "ntstatus.h"
25#define WIN32_NO_STATUS
26#include "windef.h"
27#include "winbase.h"
28#include "winternl.h"
29#include "wine/test.h"
30
31static NTSTATUS (WINAPI *pRtlMultiByteToUnicodeN)( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
32 LPCSTR src, DWORD srclen );
33static NTSTATUS (WINAPI *pRtlQueryEnvironmentVariable_U)(PWSTR, PUNICODE_STRING, PUNICODE_STRING);
34static NTSTATUS (WINAPI* pRtlQueryEnvironmentVariable)(WCHAR*, WCHAR*, SIZE_T, WCHAR*, SIZE_T, SIZE_T*);
35static NTSTATUS (WINAPI *pRtlExpandEnvironmentStrings)(WCHAR*, WCHAR*, SIZE_T, WCHAR*, SIZE_T, SIZE_T*);
36static NTSTATUS (WINAPI *pRtlExpandEnvironmentStrings_U)(LPWSTR, PUNICODE_STRING, PUNICODE_STRING, PULONG);
37static NTSTATUS (WINAPI *pRtlCreateProcessParameters)(RTL_USER_PROCESS_PARAMETERS**,
38 const UNICODE_STRING*, const UNICODE_STRING*,
39 const UNICODE_STRING*, const UNICODE_STRING*,
40 PWSTR, const UNICODE_STRING*, const UNICODE_STRING*,
41 const UNICODE_STRING*, const UNICODE_STRING*);
42static void (WINAPI *pRtlDestroyProcessParameters)(RTL_USER_PROCESS_PARAMETERS *);
43
44static void *initial_env;
45
46static WCHAR small_env[] = {'f','o','o','=','t','o','t','o',0,
47 'f','o','=','t','i','t','i',0,
48 'f','o','o','o','=','t','u','t','u',0,
49 's','r','=','a','n','=','o','u','o',0,
50 'g','=','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
51 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
52 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
53 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
54 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
55 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
56 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
57 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
58 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
59 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0,
60 '=','o','O','H','=','I','I','I',0,
61 'n','u','l','=',0,
62 0};
63
64static void testQuery(void)
65{
66 struct test
67 {
68 const char *var;
69 int len;
70 NTSTATUS status;
71 const char *val;
72 NTSTATUS alt;
73 };
74
75 static const struct test tests[] =
76 {
77 {"foo", 256, STATUS_SUCCESS, "toto"},
78 {"FoO", 256, STATUS_SUCCESS, "toto"},
79 {"foo=", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
80 {"foo ", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
81 {"foo", 1, STATUS_BUFFER_TOO_SMALL, "toto"},
82 {"foo", 3, STATUS_BUFFER_TOO_SMALL, "toto"},
83 {"foo", 4, STATUS_SUCCESS, "toto", STATUS_BUFFER_TOO_SMALL},
84 {"foo", 5, STATUS_SUCCESS, "toto"},
85 {"fooo", 256, STATUS_SUCCESS, "tutu"},
86 {"f", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
87 {"g", 256, STATUS_SUCCESS, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
88"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"},
89 {"sr=an", 256, STATUS_SUCCESS, "ouo", STATUS_VARIABLE_NOT_FOUND},
90 {"sr", 256, STATUS_SUCCESS, "an=ouo"},
91 {"=oOH", 256, STATUS_SUCCESS, "III"},
92 {"", 256, STATUS_VARIABLE_NOT_FOUND, NULL},
93 {"nul", 256, STATUS_SUCCESS, ""},
94 {NULL, 0, 0, NULL}
95 };
96
97 WCHAR bn[257];
98 WCHAR bv[257];
99 UNICODE_STRING name;
100 UNICODE_STRING value;
101 NTSTATUS nts;
102 SIZE_T name_length;
103 SIZE_T value_length;
104 SIZE_T return_length;
105 unsigned int i;
106
107 for (i = 0; tests[i].var; i++)
108 {
109 const struct test *test = &tests[i];
110 name.Length = strlen(test->var) * 2;
111 name.MaximumLength = name.Length + 2;
112 name.Buffer = bn;
113 value.Length = 0;
114 value.MaximumLength = test->len * 2;
115 value.Buffer = bv;
116 bv[test->len] = '@';
117
118 pRtlMultiByteToUnicodeN( bn, sizeof(bn), NULL, test->var, strlen(test->var)+1 );
119 nts = pRtlQueryEnvironmentVariable_U(small_env, &name, &value);
120 ok( nts == test->status || (test->alt && nts == test->alt),
121 "[%d]: Wrong status for '%s', expecting %lx got %lx\n",
122 i, test->var, test->status, nts );
123 if (nts == test->status) switch (nts)
124 {
125 case STATUS_SUCCESS:
126 pRtlMultiByteToUnicodeN( bn, sizeof(bn), NULL, test->val, strlen(test->val)+1 );
127 ok( value.Length == strlen(test->val) * sizeof(WCHAR), "Wrong length %d for %s\n",
128 value.Length, test->var );
129 ok((value.Length == strlen(test->val) * sizeof(WCHAR) && memcmp(bv, bn, value.Length) == 0) ||
130 lstrcmpW(bv, bn) == 0,
131 "Wrong result for %s/%d\n", test->var, test->len);
132 ok(bv[test->len] == '@', "Writing too far away in the buffer for %s/%d\n", test->var, test->len);
133 break;
134 case STATUS_BUFFER_TOO_SMALL:
135 ok( value.Length == strlen(test->val) * sizeof(WCHAR),
136 "Wrong returned length %d (too small buffer) for %s\n", value.Length, test->var );
137 break;
138 }
139 }
140
141 if (pRtlQueryEnvironmentVariable)
142 {
143 for (i = 0; tests[i].var; i++)
144 {
145 const struct test* test = &tests[i];
146 name_length = strlen(test->var);
147 value_length = test->len;
148 value.Buffer = bv;
149 bv[test->len] = '@';
150
151 pRtlMultiByteToUnicodeN(bn, sizeof(bn), NULL, test->var, strlen(test->var) + 1);
152 nts = pRtlQueryEnvironmentVariable(small_env, bn, name_length, bv, value_length, &return_length);
153 ok(nts == test->status || (test->alt && nts == test->alt),
154 "[%d]: Wrong status for '%s', expecting %lx got %lx\n",
155 i, test->var, test->status, nts);
156 if (nts == test->status) switch (nts)
157 {
158 case STATUS_SUCCESS:
159 pRtlMultiByteToUnicodeN(bn, sizeof(bn), NULL, test->val, strlen(test->val) + 1);
160 ok(return_length == strlen(test->val), "Wrong length %Id for %s\n",
161 return_length, test->var);
162 ok(!memcmp(bv, bn, return_length), "Wrong result for %s/%d\n", test->var, test->len);
163 ok(bv[test->len] == '@', "Writing too far away in the buffer for %s/%d\n", test->var, test->len);
164 break;
165 case STATUS_BUFFER_TOO_SMALL:
166 ok(return_length == (strlen(test->val) + 1),
167 "Wrong returned length %Id (too small buffer) for %s\n", return_length, test->var);
168 break;
169 }
170 }
171 }
172 else win_skip("RtlQueryEnvironmentVariable not available, skipping tests\n");
173}
174
175static void testExpand(void)
176{
177 static const struct test
178 {
179 const char *src;
180 const char *dst;
181 } tests[] =
182 {
183 {"hello%foo%world", "hellototoworld"},
184 {"hello%=oOH%world", "helloIIIworld"},
185 {"hello%foo", "hello%foo"},
186 {"hello%bar%world", "hello%bar%world"},
187 /*
188 * {"hello%foo%world%=oOH%eeck", "hellototoworldIIIeeck"},
189 * Interestingly enough, with a 8 WCHAR buffers, we get on 2k:
190 * helloIII
191 * so it seems like strings overflowing the buffer are written
192 * (truncated) but the write cursor is not advanced :-/
193 */
194 {NULL, NULL}
195 };
196
197 const struct test* test;
198 NTSTATUS nts;
199 UNICODE_STRING us_src, us_dst;
200 WCHAR src[256], dst[256], rst[256];
201 ULONG ul;
202
203 for (test = tests; test->src; test++)
204 {
205 pRtlMultiByteToUnicodeN(src, sizeof(src), NULL, test->src, strlen(test->src)+1);
206 pRtlMultiByteToUnicodeN(rst, sizeof(rst), NULL, test->dst, strlen(test->dst)+1);
207
208 us_src.Length = strlen(test->src) * sizeof(WCHAR);
209 us_src.MaximumLength = us_src.Length + 2;
210 us_src.Buffer = src;
211
212 us_dst.Length = 0;
213 us_dst.MaximumLength = 0;
214 us_dst.Buffer = NULL;
215
216 nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
217 ok(nts == STATUS_BUFFER_TOO_SMALL, "Call failed (%lu)\n", nts);
218 ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
219 "Wrong returned length for %s: %lu\n", test->src, ul );
220
221 us_dst.Length = 0;
222 us_dst.MaximumLength = sizeof(dst);
223 us_dst.Buffer = dst;
224
225 nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
226 ok(nts == STATUS_SUCCESS, "Call failed (%lu)\n", nts);
227 ok(ul == us_dst.Length + sizeof(WCHAR),
228 "Wrong returned length for %s: %lu\n", test->src, ul);
229 ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
230 "Wrong returned length for %s: %lu\n", test->src, ul);
231 ok(lstrcmpW(dst, rst) == 0, "Wrong result for %s: expecting %s\n",
232 test->src, test->dst);
233
234 us_dst.Length = 0;
235 us_dst.MaximumLength = 8 * sizeof(WCHAR);
236 us_dst.Buffer = dst;
237 dst[8] = '-';
238 nts = pRtlExpandEnvironmentStrings_U(small_env, &us_src, &us_dst, &ul);
239 ok(nts == STATUS_BUFFER_TOO_SMALL, "Call failed (%lu)\n", nts);
240 ok(ul == strlen(test->dst) * sizeof(WCHAR) + sizeof(WCHAR),
241 "Wrong returned length for %s (with buffer too small): %lu\n", test->src, ul);
242 ok(dst[8] == '-', "Writing too far in buffer (got %c/%d)\n", dst[8], dst[8]);
243 }
244
245}
246
247static void test_RtlExpandEnvironmentStrings(void)
248{
249 int i;
250 WCHAR buf[256];
251 HRESULT status;
252 UNICODE_STRING us_src, us_dst, us_name, us_value;
253 static const struct test_info
254 {
255 const WCHAR *input;
256 const WCHAR *expected_str;
257 int count_in;
258 int expected_count_out;
259 } tests[] =
260 {
261 /* 0 */ { L"Long long value", L"abcdefghijklmnopqrstuv", 0, 16 },
262 /* 1 */ { L"Long long value", L"abcdefghijklmnopqrstuv", 1, 16 },
263 /* 2 */ { L"Long long value", L"Lbcdefghijklmnopqrstuv", 2, 16 },
264 /* 3 */ { L"Long long value", L"Locdefghijklmnopqrstuv", 3, 16 },
265 /* 4 */ { L"Long long value", L"Long long valuopqrstuv", 15, 16 },
266 /* 5 */ { L"Long long value", L"Long long value", 16, 16 },
267 /* 6 */ { L"Long long value", L"Long long value", 17, 16 },
268 /* 7 */ { L"%TVAR% long long", L"abcdefghijklmnopqrstuv", 0, 15 },
269 /* 8 */ { L"%TVAR% long long", L"", 1, 15 },
270 /* 9 */ { L"%TVAR% long long", L"", 2, 15 },
271 /* 10 */ { L"%TVAR% long long", L"", 4, 15 },
272 /* 11 */ { L"%TVAR% long long", L"WINE", 5, 15 },
273 /* 12 */ { L"%TVAR% long long", L"WINE fghijklmnopqrstuv", 6, 15 },
274 /* 13 */ { L"%TVAR% long long", L"WINE lghijklmnopqrstuv", 7, 15 },
275 /* 14 */ { L"%TVAR% long long", L"WINE long long", 15, 15 },
276 /* 15 */ { L"%TVAR% long long", L"WINE long long", 16, 15 },
277 /* 16 */ { L"%TVAR%%TVAR% long", L"", 4, 14 },
278 /* 17 */ { L"%TVAR%%TVAR% long", L"WINE", 5, 14 },
279 /* 18 */ { L"%TVAR%%TVAR% long", L"WINE", 6, 14 },
280 /* 19 */ { L"%TVAR%%TVAR% long", L"WINE", 8, 14 },
281 /* 20 */ { L"%TVAR%%TVAR% long", L"WINEWINE", 9, 14 },
282 /* 21 */ { L"%TVAR%%TVAR% long", L"WINEWINE jklmnopqrstuv", 10, 14 },
283 /* 22 */ { L"%TVAR%%TVAR% long", L"WINEWINE long", 14, 14 },
284 /* 23 */ { L"%TVAR%%TVAR% long", L"WINEWINE long", 15, 14 },
285 /* 24 */ { L"%TVAR% %TVAR% long", L"WINE", 5, 15 },
286 /* 25 */ { L"%TVAR% %TVAR% long", L"WINE ", 6, 15 },
287 /* 26 */ { L"%TVAR% %TVAR% long", L"WINE ", 8, 15 },
288 /* 27 */ { L"%TVAR% %TVAR% long", L"WINE ", 9, 15 },
289 /* 28 */ { L"%TVAR% %TVAR% long", L"WINE WINE", 10, 15 },
290 /* 29 */ { L"%TVAR% %TVAR% long", L"WINE WINE klmnopqrstuv", 11, 15 },
291 /* 30 */ { L"%TVAR% %TVAR% long", L"WINE WINE llmnopqrstuv", 12, 15 },
292 /* 31 */ { L"%TVAR% %TVAR% long", L"WINE WINE lonnopqrstuv", 14, 15 },
293 /* 32 */ { L"%TVAR% %TVAR% long", L"WINE WINE long", 15, 15 },
294 /* 33 */ { L"%TVAR% %TVAR% long", L"WINE WINE long", 16, 15 },
295 /* 34 */ { L"%TVAR2% long long", L"abcdefghijklmnopqrstuv", 1, 18 },
296 /* 35 */ { L"%TVAR2% long long", L"%bcdefghijklmnopqrstuv", 2, 18 },
297 /* 36 */ { L"%TVAR2% long long", L"%TVdefghijklmnopqrstuv", 4, 18 },
298 /* 37 */ { L"%TVAR2% long long", L"%TVAR2ghijklmnopqrstuv", 7, 18 },
299 /* 38 */ { L"%TVAR2% long long", L"%TVAR2%hijklmnopqrstuv", 8, 18 },
300 /* 39 */ { L"%TVAR2% long long", L"%TVAR2% ijklmnopqrstuv", 9, 18 },
301 /* 40 */ { L"%TVAR2% long long", L"%TVAR2% ljklmnopqrstuv", 10, 18 },
302 /* 41 */ { L"%TVAR2% long long", L"%TVAR2% long long", 18, 18 },
303 /* 42 */ { L"%TVAR2% long long", L"%TVAR2% long long", 19, 18 },
304 /* 43 */ { L"%TVAR long long", L"abcdefghijklmnopqrstuv", 1, 16 },
305 /* 44 */ { L"%TVAR long long", L"%bcdefghijklmnopqrstuv", 2, 16 },
306 /* 45 */ { L"%TVAR long long", L"%Tcdefghijklmnopqrstuv", 3, 16 },
307 /* 46 */ { L"%TVAR long long", L"%TVAR long lonopqrstuv", 15, 16 },
308 /* 47 */ { L"%TVAR long long", L"%TVAR long long", 16, 16 },
309 /* 48 */ { L"%TVAR long long", L"%TVAR long long", 17, 16 },
310 };
311
312 RtlInitUnicodeString(&us_name, L"TVAR");
313 RtlInitUnicodeString(&us_value, L"WINE");
314 status = RtlSetEnvironmentVariable(NULL, &us_name, &us_value);
315 ok(status == STATUS_SUCCESS, "RtlSetEnvironmentVariable failed with %lx\n", status);
316
317#ifdef __REACTOS__
318 if (pRtlExpandEnvironmentStrings != NULL)
319#endif
320 for (i = 0; i < ARRAY_SIZE(tests); i++)
321 {
322 const struct test_info *test = &tests[i];
323 SIZE_T out_len;
324 HRESULT expected_status = test->count_in >= test->expected_count_out ? STATUS_SUCCESS : STATUS_BUFFER_TOO_SMALL;
325
326 wcscpy(buf, L"abcdefghijklmnopqrstuv");
327 status = pRtlExpandEnvironmentStrings(NULL, (WCHAR*)test->input, wcslen(test->input), buf, test->count_in, &out_len);
328 ok(out_len == test->expected_count_out, "Test %d: got %Iu\n", i, out_len);
329 ok(status == expected_status, "Test %d: Expected status %lx, got %lx\n", i, expected_status, status);
330 ok(!wcscmp(buf, test->expected_str), "Test %d: got %s\n", i, debugstr_w(buf));
331 }
332
333 for (i = 0; i < ARRAY_SIZE(tests); i++)
334 {
335 const struct test_info *test = &tests[i];
336 DWORD out_len;
337 HRESULT expected_status = test->count_in >= test->expected_count_out ? STATUS_SUCCESS : STATUS_BUFFER_TOO_SMALL;
338
339 us_src.Length = wcslen(test->input) * sizeof(WCHAR);
340 us_src.MaximumLength = us_src.Length;
341 us_src.Buffer = (WCHAR*)test->input;
342
343 us_dst.Length = test->count_in * sizeof(WCHAR);
344 us_dst.MaximumLength = us_dst.Length;
345 us_dst.Buffer = buf;
346
347 wcscpy(buf, L"abcdefghijklmnopqrstuv");
348 status = pRtlExpandEnvironmentStrings_U(NULL, &us_src, &us_dst, &out_len);
349 ok(out_len / sizeof(WCHAR) == test->expected_count_out, "Test %d: got %lu\n", i, out_len);
350 ok(status == expected_status, "Test %d: Expected status %lx, got %lx\n", i, expected_status, status);
351 ok(!wcscmp(buf, test->expected_str), "Test %d: got %s\n", i, debugstr_w(buf));
352 }
353 status = RtlSetEnvironmentVariable(NULL, &us_name, NULL);
354 ok(status == STATUS_SUCCESS, "RtlSetEnvironmentVariable failed with %lx\n", status);
355}
356
357static WCHAR *get_params_string( RTL_USER_PROCESS_PARAMETERS *params, UNICODE_STRING *str )
358{
359 if (params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED) return str->Buffer;
360 return (WCHAR *)((char *)params + (UINT_PTR)str->Buffer);
361}
362
363static SIZE_T get_env_length( const WCHAR *env )
364{
365 const WCHAR *end = env;
366 while (*end) end += wcslen(end) + 1;
367 return end + 1 - env;
368}
369
370static UINT_PTR align(UINT_PTR size, unsigned int alignment)
371{
372 return (size + (alignment - 1)) & ~(alignment - 1);
373}
374
375static UINT_PTR check_string_( int line, RTL_USER_PROCESS_PARAMETERS *params, UNICODE_STRING *str,
376 const UNICODE_STRING *expect, UINT_PTR pos )
377{
378 if (expect)
379 {
380 ok_(__FILE__,line)( str->Length == expect->Length, "wrong length %u/%u\n",
381 str->Length, expect->Length );
382 ok_(__FILE__,line)( str->MaximumLength == expect->MaximumLength,
383 "wrong maxlength %u/%u\n", str->MaximumLength, expect->MaximumLength );
384 }
385 if (!str->MaximumLength)
386 {
387 ok_(__FILE__,line)( str->Buffer == NULL, "buffer not null %p\n", str->Buffer );
388 return pos;
389 }
390 if (expect)
391 ok_(__FILE__,line)( (UINT_PTR)str->Buffer == align(pos, sizeof(void *)) ||
392 broken( (UINT_PTR)str->Buffer == align(pos, 4) ), /* win7 */
393 "wrong buffer %Ix/%Ix\n", (UINT_PTR)str->Buffer, pos );
394 else /* initial params are not aligned */
395 ok_(__FILE__,line)( (UINT_PTR)str->Buffer == pos,
396 "wrong buffer %Ix/%Ix\n", (UINT_PTR)str->Buffer, pos );
397 if (str->Length < str->MaximumLength)
398 {
399 WCHAR *ptr = get_params_string( params, str );
400 ok_(__FILE__,line)( !ptr[str->Length / sizeof(WCHAR)], "string not null-terminated %s\n",
401 wine_dbgstr_wn( ptr, str->MaximumLength / sizeof(WCHAR) ));
402 }
403 return (UINT_PTR)str->Buffer + str->MaximumLength;
404}
405#define check_string(params,str,expect,pos) check_string_(__LINE__,params,str,expect,pos)
406
407static void test_process_params(void)
408{
409 static WCHAR empty[] = {0};
410 static const UNICODE_STRING empty_str = { 0, sizeof(empty), empty };
411 static const UNICODE_STRING null_str = { 0, 0, NULL };
412 static WCHAR exeW[] = {'c',':','\\','f','o','o','.','e','x','e',0};
413 static WCHAR dummyW[] = {'d','u','m','m','y','1',0};
414 static WCHAR dummy_dirW[MAX_PATH] = {'d','u','m','m','y','2',0};
415 static WCHAR dummy_env[] = {'a','=','b',0,'c','=','d',0,0};
416 UNICODE_STRING image = { sizeof(exeW) - sizeof(WCHAR), sizeof(exeW), exeW };
417 UNICODE_STRING dummy = { sizeof(dummyW) - sizeof(WCHAR), sizeof(dummyW), dummyW };
418 UNICODE_STRING dummy_dir = { 6*sizeof(WCHAR), sizeof(dummy_dirW), dummy_dirW };
419 RTL_USER_PROCESS_PARAMETERS *params = NULL;
420 RTL_USER_PROCESS_PARAMETERS *cur_params = NtCurrentTeb()->Peb->ProcessParameters;
421 SIZE_T size;
422 WCHAR *str;
423 UINT_PTR pos;
424 NTSTATUS status = pRtlCreateProcessParameters( &params, &image, NULL, NULL, NULL, NULL,
425 NULL, NULL, NULL, NULL );
426 ok( !status, "failed %lx\n", status );
427 size = HeapSize( GetProcessHeap(), 0, params );
428 ok( size != ~(SIZE_T)0, "not a heap block %p\n", params );
429 ok( params->AllocationSize == params->Size,
430 "wrong AllocationSize %lx/%lx\n", params->AllocationSize, params->Size );
431 ok( params->Size < size || /* __REACTOS__ Win 2003: */ broken(params->Size == size), "wrong Size %lx/%Ix\n", params->Size, size);
432 ok( params->Flags == 0, "wrong Flags %lu\n", params->Flags );
433 ok( params->DebugFlags == 0, "wrong Flags %lu\n", params->DebugFlags );
434 ok( params->ConsoleHandle == 0, "wrong ConsoleHandle %p\n", params->ConsoleHandle );
435#ifdef __REACTOS__
436 if (GetEnvironmentVariableW(L"ROSAUTOTEST_DIR", NULL, 0))
437 ok( params->ConsoleFlags == 1, "wrong ConsoleFlags %lu\n", params->ConsoleFlags );
438 else
439#endif
440 ok( params->ConsoleFlags == 0, "wrong ConsoleFlags %lu\n", params->ConsoleFlags );
441 ok( params->hStdInput == 0, "wrong hStdInput %p\n", params->hStdInput );
442 ok( params->hStdOutput == 0, "wrong hStdOutput %p\n", params->hStdOutput );
443 ok( params->hStdError == 0, "wrong hStdError %p\n", params->hStdError );
444 ok( params->dwX == 0, "wrong dwX %lu\n", params->dwX );
445 ok( params->dwY == 0, "wrong dwY %lu\n", params->dwY );
446 ok( params->dwXSize == 0, "wrong dwXSize %lu\n", params->dwXSize );
447 ok( params->dwYSize == 0, "wrong dwYSize %lu\n", params->dwYSize );
448 ok( params->dwXCountChars == 0, "wrong dwXCountChars %lu\n", params->dwXCountChars );
449 ok( params->dwYCountChars == 0, "wrong dwYCountChars %lu\n", params->dwYCountChars );
450 ok( params->dwFillAttribute == 0, "wrong dwFillAttribute %lu\n", params->dwFillAttribute );
451 ok( params->dwFlags == 0, "wrong dwFlags %lu\n", params->dwFlags );
452 ok( params->wShowWindow == 0, "wrong wShowWindow %lu\n", params->wShowWindow );
453 pos = (UINT_PTR)params->CurrentDirectory.DosPath.Buffer;
454
455 ok( params->CurrentDirectory.DosPath.MaximumLength == MAX_PATH * sizeof(WCHAR),
456 "wrong length %x\n", params->CurrentDirectory.DosPath.MaximumLength );
457 pos = check_string( params, &params->CurrentDirectory.DosPath,
458 &cur_params->CurrentDirectory.DosPath, pos );
459 if (params->DllPath.MaximumLength)
460 pos = check_string( params, &params->DllPath, &cur_params->DllPath, pos );
461 else
462 pos = check_string( params, &params->DllPath, &null_str, pos );
463 pos = check_string( params, &params->ImagePathName, &image, pos );
464 pos = check_string( params, &params->CommandLine, &image, pos );
465 pos = check_string( params, &params->WindowTitle, &empty_str, pos );
466 pos = check_string( params, &params->Desktop, &empty_str, pos );
467 pos = check_string( params, &params->ShellInfo, &empty_str, pos );
468 pos = check_string( params, &params->RuntimeInfo, &null_str, pos );
469 pos = align(pos, 4);
470 ok( pos == params->Size || pos + 4 == params->Size,
471 "wrong pos %Ix/%lx\n", pos, params->Size );
472 pos = params->Size;
473 ok( (char *)params->Environment - (char *)params == (UINT_PTR)pos || broken(/* __REACTOS__ */ GetNTVersion() < _WIN32_WINNT_VISTA),
474 "wrong env %Ix/%Ix\n", (UINT_PTR)((char *)params->Environment - (char *)params), pos);
475 pos += get_env_length(params->Environment) * sizeof(WCHAR);
476 ok( align(pos, sizeof(void *)) == size ||
477 broken( align(pos, 4) == size ) || broken(/* __REACTOS__ */ GetNTVersion() < _WIN32_WINNT_VISTA), "wrong size %Ix/%Ix\n", pos, size );
478 ok( params->EnvironmentSize == size - ((char *)params->Environment - (char *)params) || broken(/* __REACTOS__ */ GetNTVersion() < _WIN32_WINNT_VISTA),
479 "wrong len %Ix/%Ix\n", params->EnvironmentSize,
480 size - ((char *)params->Environment - (char *)params) );
481 pRtlDestroyProcessParameters( params );
482
483 status = pRtlCreateProcessParameters( &params, &image, &dummy, &dummy, &dummy, dummy_env,
484 &dummy, &dummy, &dummy, &dummy );
485 ok( !status, "failed %lx\n", status );
486 size = HeapSize( GetProcessHeap(), 0, params );
487 ok( size != ~(SIZE_T)0, "not a heap block %p\n", params );
488 ok( params->AllocationSize == params->Size,
489 "wrong AllocationSize %lx/%lx\n", params->AllocationSize, params->Size );
490 ok( params->Size < size || broken(/* __REACTOS__ */ GetNTVersion() < _WIN32_WINNT_VISTA), "wrong Size %lx/%Ix\n", params->Size, size );
491 pos = (UINT_PTR)params->CurrentDirectory.DosPath.Buffer;
492
493 if (params->CurrentDirectory.DosPath.Length == dummy_dir.Length + sizeof(WCHAR))
494 {
495 /* win10 appends a backslash */
496 dummy_dirW[dummy_dir.Length / sizeof(WCHAR)] = '\\';
497 dummy_dir.Length += sizeof(WCHAR);
498 }
499 pos = check_string( params, &params->CurrentDirectory.DosPath, &dummy_dir, pos );
500 pos = check_string( params, &params->DllPath, &dummy, pos );
501 pos = check_string( params, &params->ImagePathName, &image, pos );
502 pos = check_string( params, &params->CommandLine, &dummy, pos );
503 pos = check_string( params, &params->WindowTitle, &dummy, pos );
504 pos = check_string( params, &params->Desktop, &dummy, pos );
505 pos = check_string( params, &params->ShellInfo, &dummy, pos );
506 pos = check_string( params, &params->RuntimeInfo, &dummy, pos );
507 pos = align(pos, 4);
508 ok( pos == params->Size || pos + 4 == params->Size,
509 "wrong pos %Ix/%lx\n", pos, params->Size );
510 pos = params->Size;
511 ok( (char *)params->Environment - (char *)params == pos || broken(/* __REACTOS__ */ GetNTVersion() < _WIN32_WINNT_VISTA),
512 "wrong env %Ix/%Ix\n", (UINT_PTR)((char *)params->Environment - (char *)params), pos);
513 pos += get_env_length(params->Environment) * sizeof(WCHAR);
514 ok( align(pos, sizeof(void *)) == size ||
515 broken( align(pos, 4) == size || broken(/* __REACTOS__ */ GetNTVersion() < _WIN32_WINNT_VISTA) ), "wrong size %Ix/%Ix\n", pos, size );
516 ok( params->EnvironmentSize == size - ((char *)params->Environment - (char *)params) || broken(/* __REACTOS__ */ GetNTVersion() < _WIN32_WINNT_VISTA),
517 "wrong len %Ix/%Ix\n", params->EnvironmentSize,
518 size - ((char *)params->Environment - (char *)params) );
519 pRtlDestroyProcessParameters( params );
520
521 /* also test the actual parameters of the current process */
522
523 ok( cur_params->Flags & PROCESS_PARAMS_FLAG_NORMALIZED, "current params not normalized\n" );
524#ifdef __REACTOS__
525 if ((GetNTVersion() < _WIN32_WINNT_VISTA) || is_reactos()) size = 0; else /* Win2003/ReactOS do not allocate this from the heap */
526#endif
527 size = HeapSize( GetProcessHeap(), 0, cur_params );
528 ok( size != ~(SIZE_T)0, "not a heap block %p\n", cur_params );
529 ok( cur_params->AllocationSize == cur_params->Size,
530 "wrong AllocationSize %lx/%lx\n", cur_params->AllocationSize, cur_params->Size );
531 ok( cur_params->Size == size, "wrong Size %lx/%Ix\n", cur_params->Size, size );
532
533 /* CurrentDirectory points outside the params, and DllPath may be null */
534 pos = (UINT_PTR)cur_params->DllPath.Buffer;
535 if (!pos) pos = (UINT_PTR)cur_params->ImagePathName.Buffer;
536 pos = check_string( cur_params, &cur_params->DllPath, NULL, pos );
537 pos = check_string( cur_params, &cur_params->ImagePathName, NULL, pos );
538 pos = check_string( cur_params, &cur_params->CommandLine, NULL, pos );
539 pos = check_string( cur_params, &cur_params->WindowTitle, NULL, pos );
540 pos = check_string( cur_params, &cur_params->Desktop, NULL, pos );
541 pos = check_string( cur_params, &cur_params->ShellInfo, NULL, pos );
542 pos = check_string( cur_params, &cur_params->RuntimeInfo, NULL, pos );
543 /* environment may follow */
544 str = (WCHAR *)pos;
545 if (pos - (UINT_PTR)cur_params < cur_params->Size) str += get_env_length(str);
546 ok( (char *)str == (char *)cur_params + cur_params->Size,
547 "wrong end ptr %p/%p\n", str, (char *)cur_params + cur_params->Size );
548
549 /* initial environment is a separate block */
550
551 ok( (char *)initial_env < (char *)cur_params || (char *)initial_env >= (char *)cur_params + size,
552 "initial environment inside block %p / %p\n", cur_params, initial_env );
553#ifdef __REACTOS__
554 if ((GetNTVersion() < _WIN32_WINNT_VISTA) || is_reactos()) size = 0; else /* Win2003/ReactOS does not allocate this from the heap */
555#endif
556 size = HeapSize( GetProcessHeap(), 0, initial_env );
557 ok( size != ~(SIZE_T)0, "env is not a heap block %p / %p\n", cur_params, initial_env );
558 ok( cur_params->EnvironmentSize == size,
559 "wrong len %Ix/%Ix\n", cur_params->EnvironmentSize, size );
560}
561
562static NTSTATUS set_env_var(WCHAR **env, const WCHAR *var, const WCHAR *value)
563{
564 UNICODE_STRING var_string, value_string;
565 RtlInitUnicodeString(&var_string, var);
566 if (value) RtlInitUnicodeString(&value_string, value);
567 return RtlSetEnvironmentVariable(env, &var_string, value ? &value_string : NULL);
568}
569
570static void check_env_var_(int line, const char *var, const char *value)
571{
572 char buffer[20];
573 DWORD size = GetEnvironmentVariableA(var, buffer, sizeof(buffer));
574 if (value)
575 {
576 ok_(__FILE__, line)(size == strlen(value), "wrong size %lu\n", size);
577 ok_(__FILE__, line)(!strcmp(buffer, value), "wrong value %s\n", debugstr_a(buffer));
578 }
579 else
580 {
581 ok_(__FILE__, line)(!size, "wrong size %lu\n", size);
582 ok_(__FILE__, line)(GetLastError() == ERROR_ENVVAR_NOT_FOUND, "got error %lu\n", GetLastError());
583 }
584}
585#define check_env_var(a, b) check_env_var_(__LINE__, a, b)
586
587static void test_RtlSetCurrentEnvironment(void)
588{
589 NTSTATUS status;
590 WCHAR *old_env, *env, *prev;
591 BOOL ret;
592 SIZE_T size;
593
594 status = RtlCreateEnvironment(FALSE, &env);
595 ok(!status, "got %#lx\n", status);
596
597 ret = SetEnvironmentVariableA("testenv1", "heis");
598 ok(ret, "got error %lu\n", GetLastError());
599 ret = SetEnvironmentVariableA("testenv2", "dyo");
600 ok(ret, "got error %lu\n", GetLastError());
601
602 status = set_env_var(&env, L"testenv1", L"unus");
603 ok(!status, "got %#lx\n", status);
604 status = set_env_var(&env, L"testenv3", L"tres");
605 ok(!status, "got %#lx\n", status);
606
607 old_env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
608 ok(NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == get_env_length(old_env) * sizeof(WCHAR),
609 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize);
610#ifdef __REACTOS__
611 return; /* ReactOS does not allocate this from the heap */
612#endif
613 ok(NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == HeapSize( GetProcessHeap(), 0, old_env ),
614 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize);
615
616 RtlSetCurrentEnvironment(env, &prev);
617 ok(prev == old_env, "got wrong previous env %p\n", prev);
618 ok(NtCurrentTeb()->Peb->ProcessParameters->Environment == env, "got wrong current env\n");
619 ok(NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == get_env_length(env) * sizeof(WCHAR),
620 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize);
621 ok(NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == HeapSize( GetProcessHeap(), 0, env ),
622 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize);
623
624 check_env_var("testenv1", "unus");
625 check_env_var("testenv2", NULL);
626 check_env_var("testenv3", "tres");
627 check_env_var("PATH", NULL);
628
629 env = HeapReAlloc( GetProcessHeap(), 0, env, HeapSize( GetProcessHeap(), 0, env) + 120 );
630 RtlSetCurrentEnvironment(env, &prev);
631 ok(NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == HeapSize( GetProcessHeap(), 0, env ),
632 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize);
633
634 RtlSetCurrentEnvironment(old_env, NULL);
635 ok(NtCurrentTeb()->Peb->ProcessParameters->Environment == old_env, "got wrong current env\n");
636 ok(NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == get_env_length(old_env) * sizeof(WCHAR),
637 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize);
638 ok(NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == HeapSize( GetProcessHeap(), 0, old_env ),
639 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize);
640
641 check_env_var("testenv1", "heis");
642 check_env_var("testenv2", "dyo");
643 check_env_var("testenv3", NULL);
644
645 env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
646 size = get_env_length(env) * sizeof(WCHAR);
647 ok( NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == size,
648 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize );
649 ok( size == HeapSize( GetProcessHeap(), 0, env ),
650 "got wrong size %Iu / %Iu\n", size, HeapSize( GetProcessHeap(), 0, env ));
651
652 SetEnvironmentVariableA("testenv1", NULL);
653 SetEnvironmentVariableA("testenv2", NULL);
654
655 env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
656 ok( NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize == size,
657 "got wrong size %Iu\n", NtCurrentTeb()->Peb->ProcessParameters->EnvironmentSize );
658 ok( size == HeapSize( GetProcessHeap(), 0, env ),
659 "got wrong size %Iu / %Iu\n", size, HeapSize( GetProcessHeap(), 0, env ));
660 ok( size > get_env_length(env) * sizeof(WCHAR), "got wrong size %Iu\n", size );
661}
662
663static void query_env_var_(int line, WCHAR *env, const WCHAR *var, const WCHAR *value)
664{
665 UNICODE_STRING var_string, value_string;
666 WCHAR value_buffer[9];
667 NTSTATUS status;
668
669 RtlInitUnicodeString(&var_string, var);
670 value_string.Buffer = value_buffer;
671 value_string.MaximumLength = sizeof(value_buffer);
672
673 status = RtlQueryEnvironmentVariable_U(env, &var_string, &value_string);
674 if (value)
675 {
676 ok_(__FILE__, line)(!status, "got %#lx\n", status);
677 ok_(__FILE__, line)(value_string.Length/sizeof(WCHAR) == wcslen(value),
678 "wrong size %Iu\n", value_string.Length/sizeof(WCHAR));
679 ok_(__FILE__, line)(!wcscmp(value_string.Buffer, value), "wrong value %s\n", debugstr_w(value_string.Buffer));
680 }
681 else
682 ok_(__FILE__, line)(status == STATUS_VARIABLE_NOT_FOUND, "got %#lx\n", status);
683}
684#define query_env_var(a, b, c) query_env_var_(__LINE__, a, b, c)
685
686static void test_RtlSetEnvironmentVariable(void)
687{
688 NTSTATUS status;
689 WCHAR *env;
690
691 status = RtlCreateEnvironment(FALSE, &env);
692 ok(!status, "got %#lx\n", status);
693
694 status = set_env_var(&env, L"cat", L"dog");
695 ok(!status, "got %#lx\n", status);
696 query_env_var(env, L"cat", L"dog");
697
698 status = set_env_var(&env, L"cat", L"horse");
699 ok(!status, "got %#lx\n", status);
700 query_env_var(env, L"cat", L"horse");
701
702 status = set_env_var(&env, L"cat", NULL);
703 ok(!status, "got %#lx\n", status);
704 query_env_var(env, L"cat", NULL);
705
706 status = set_env_var(&env, L"cat", NULL);
707 ok(!status, "got %#lx\n", status);
708
709 status = set_env_var(&env, L"foo", L"meouw");
710 ok(!status, "got %#lx\n", status);
711 query_env_var(env, L"foo", L"meouw");
712
713 status = set_env_var(&env, L"fOo", NULL);
714 ok(!status, "got %#lx\n", status);
715 query_env_var(env, L"foo", NULL);
716
717 status = set_env_var(&env, L"horse", NULL);
718 ok(!status, "got %#lx\n", status);
719 query_env_var(env, L"horse", NULL);
720
721 status = set_env_var(&env, L"me=too", L"also");
722 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
723
724 status = set_env_var(&env, L"me", L"too=also");
725 ok(!status, "got %#lx\n", status);
726 query_env_var(env, L"me", L"too=also");
727
728 status = set_env_var(&env, L"=too", L"also");
729 ok(!status, "got %#lx\n", status);
730 query_env_var(env, L"=too", L"also");
731
732 status = set_env_var(&env, L"=", L"also");
733 ok(!status, "got %#lx\n", status);
734 query_env_var(env, L"=", L"also");
735
736 status = RtlDestroyEnvironment(env);
737 ok(!status, "got %#lx\n", status);
738}
739
740START_TEST(env)
741{
742 HMODULE mod = GetModuleHandleA("ntdll.dll");
743
744 initial_env = NtCurrentTeb()->Peb->ProcessParameters->Environment;
745
746 pRtlMultiByteToUnicodeN = (void *)GetProcAddress(mod,"RtlMultiByteToUnicodeN");
747 pRtlQueryEnvironmentVariable_U = (void*)GetProcAddress(mod, "RtlQueryEnvironmentVariable_U");
748 pRtlQueryEnvironmentVariable = (void*)GetProcAddress(mod, "RtlQueryEnvironmentVariable");
749 pRtlExpandEnvironmentStrings = (void*)GetProcAddress(mod, "RtlExpandEnvironmentStrings");
750 pRtlExpandEnvironmentStrings_U = (void*)GetProcAddress(mod, "RtlExpandEnvironmentStrings_U");
751 pRtlCreateProcessParameters = (void*)GetProcAddress(mod, "RtlCreateProcessParameters");
752 pRtlDestroyProcessParameters = (void*)GetProcAddress(mod, "RtlDestroyProcessParameters");
753
754 testQuery();
755 testExpand();
756 test_process_params();
757 test_RtlSetCurrentEnvironment();
758 test_RtlSetEnvironmentVariable();
759 test_RtlExpandEnvironmentStrings();
760}
mod
std::map< E_MODULE, HMODULE > mod
Definition: LocaleTests.cpp:68
pRtlQueryEnvironmentVariable
static FN_RtlQueryEnvironmentVariable * pRtlQueryEnvironmentVariable
Definition: RtlQueryEnvironmentVariable.c:21
expect
#define expect(EXPECTED, GOT)
Definition: SystemMenu.c:483
alignment
_Check_return_ _Ret_maybenull_ _In_ size_t alignment
Definition: align.cpp:48
GetNTVersion
#define GetNTVersion()
Definition: apitest.h:17
ok
#define ok(value,...)
Definition: atltest.h:57
broken
#define broken(x)
Definition: atltest.h:178
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
empty_str
static const TCHAR empty_str[]
Definition: dialog.c:20
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
env
static LPCWSTR LPCWSTR LPCWSTR env
Definition: db.cpp:171
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
NTSTATUS
#define NTSTATUS
Definition: precomp.h:19
empty
static const WCHAR empty[1]
Definition: string.c:47
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
GetEnvironmentVariableW
#define GetEnvironmentVariableW(x, y, z)
Definition: compat.h:755
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
HeapReAlloc
#define HeapReAlloc
Definition: compat.h:734
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
GetEnvironmentVariableA
#define GetEnvironmentVariableA(x, y, z)
Definition: compat.h:754
Peb
PPEB Peb
Definition: dllmain.c:27
SetEnvironmentVariableA
BOOL WINAPI DECLSPEC_HOTPATCH SetEnvironmentVariableA(IN LPCSTR lpName, IN LPCSTR lpValue)
Definition: environ.c:219
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4152
wcslen
_ACRTIMP size_t __cdecl wcslen(const wchar_t *)
Definition: wcs.c:2983
wcscmp
_ACRTIMP int __cdecl wcscmp(const wchar_t *, const wchar_t *)
Definition: wcs.c:1972
memcmp
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2802
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1592
strcmp
_ACRTIMP int __cdecl strcmp(const char *, const char *)
Definition: string.c:3319
ret
return ret
Definition: mutex.c:146
L
#define L(x)
Definition: resources.c:13
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
end
GLuint GLuint end
Definition: gl.h:1545
src
GLenum src
Definition: glext.h:6340
buffer
GLuint buffer
Definition: glext.h:5915
size
GLsizeiptr size
Definition: glext.h:5919
params
GLenum const GLfloat * params
Definition: glext.h:5645
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
dst
GLenum GLenum dst
Definition: glext.h:6340
val
GLuint GLfloat * val
Definition: glext.h:7180
len
GLenum GLsizei len
Definition: glext.h:6722
input
GLenum GLenum GLenum input
Definition: glext.h:9031
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NtCurrentTeb
#define NtCurrentTeb
Definition: iphlpapi_private.h:4
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
if
if(dx< 0)
Definition: linetemp.h:194
win_skip
#define win_skip
Definition: minitest.h:67
ptr
static PVOID ptr
Definition: dispmode.c:27
tests
static struct test_info tests[]
var
const char * var
Definition: shader.c:5666
dummyW
static const WCHAR dummyW[]
Definition: directory.c:87
query_env_var_
static void query_env_var_(int line, WCHAR *env, const WCHAR *var, const WCHAR *value)
Definition: env.c:663
PUNICODE_STRING
static PUNICODE_STRING
Definition: env.c:33
srclen
static DWORD LPDWORD LPCSTR DWORD srclen
Definition: env.c:32
reslen
static DWORD LPDWORD reslen
Definition: env.c:31
check_env_var_
static void check_env_var_(int line, const char *var, const char *value)
Definition: env.c:570
test_process_params
static void test_process_params(void)
Definition: env.c:407
check_env_var
#define check_env_var(a, b)
Definition: env.c:585
check_string
#define check_string(params, str, expect, pos)
Definition: env.c:405
set_env_var
static NTSTATUS set_env_var(WCHAR **env, const WCHAR *var, const WCHAR *value)
Definition: env.c:562
testExpand
static void testExpand(void)
Definition: env.c:175
align
static UINT_PTR align(UINT_PTR size, unsigned int alignment)
Definition: env.c:370
get_params_string
static WCHAR * get_params_string(RTL_USER_PROCESS_PARAMETERS *params, UNICODE_STRING *str)
Definition: env.c:357
test_RtlSetCurrentEnvironment
static void test_RtlSetCurrentEnvironment(void)
Definition: env.c:587
SIZE_T
static WCHAR SIZE_T
Definition: env.c:34
PWSTR
static const UNICODE_STRING const UNICODE_STRING const UNICODE_STRING const UNICODE_STRING PWSTR
Definition: env.c:38
get_env_length
static SIZE_T get_env_length(const WCHAR *env)
Definition: env.c:363
test_RtlExpandEnvironmentStrings
static void test_RtlExpandEnvironmentStrings(void)
Definition: env.c:247
dstlen
static DWORD dstlen
Definition: env.c:31
small_env
static WCHAR small_env[]
Definition: env.c:46
test_RtlSetEnvironmentVariable
static void test_RtlSetEnvironmentVariable(void)
Definition: env.c:686
src
static DWORD LPDWORD LPCSTR src
Definition: env.c:32
initial_env
static void * initial_env
Definition: env.c:44
PULONG
static WCHAR WCHAR SIZE_T *static WCHAR WCHAR SIZE_T *static PULONG
Definition: env.c:36
check_string_
static UINT_PTR check_string_(int line, RTL_USER_PROCESS_PARAMETERS *params, UNICODE_STRING *str, const UNICODE_STRING *expect, UINT_PTR pos)
Definition: env.c:375
testQuery
static void testQuery(void)
Definition: env.c:64
query_env_var
#define query_env_var(a, b, c)
Definition: env.c:684
UINT_PTR
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
RtlSetEnvironmentVariable
NTSYSAPI NTSTATUS NTAPI RtlSetEnvironmentVariable(_In_z_ PWSTR *Environment, _In_ PUNICODE_STRING Name, _In_ PUNICODE_STRING Value)
RtlCreateEnvironment
NTSYSAPI NTSTATUS NTAPI RtlCreateEnvironment(_In_ BOOLEAN Inherit, _Out_ PWSTR *Environment)
RtlDestroyEnvironment
NTSYSAPI VOID NTAPI RtlDestroyEnvironment(_In_ PWSTR Environment)
RtlQueryEnvironmentVariable_U
NTSYSAPI NTSTATUS NTAPI RtlQueryEnvironmentVariable_U(_In_opt_ PWSTR Environment, _In_ PCUNICODE_STRING Name, _Out_ PUNICODE_STRING Value)
RtlInitUnicodeString
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
STATUS_VARIABLE_NOT_FOUND
#define STATUS_VARIABLE_NOT_FOUND
Definition: ntstatus.h:586
WCHAR
short WCHAR
Definition: pedump.c:58
test
#define test
Definition: rosglue.h:37
wine_dbgstr_wn
#define wine_dbgstr_wn
Definition: testlist.c:2
str
const WCHAR * str
Definition: rpc_transport.c:2696
wcscpy
wcscpy
Definition: corecrt_wstring.h:120
_WIN32_WINNT_VISTA
#define _WIN32_WINNT_VISTA
Definition: sdkddkver.h:25
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
_CURDIR::DosPath
UNICODE_STRING DosPath
Definition: rtltypes.h:1362
_PEB::ProcessParameters
PRTL_USER_PROCESS_PARAMETERS ProcessParameters
Definition: btrfs_drv.h:1913
_RTL_USER_PROCESS_PARAMETERS
Definition: btrfs_drv.h:1898
_RTL_USER_PROCESS_PARAMETERS::AllocationSize
ULONG AllocationSize
Definition: winternl.h:263
_RTL_USER_PROCESS_PARAMETERS::CommandLine
UNICODE_STRING CommandLine
Definition: btrfs_drv.h:1902
_RTL_USER_PROCESS_PARAMETERS::DllPath
UNICODE_STRING DllPath
Definition: rtltypes.h:1560
_RTL_USER_PROCESS_PARAMETERS::Size
ULONG Size
Definition: winternl.h:264
_RTL_USER_PROCESS_PARAMETERS::Desktop
UNICODE_STRING Desktop
Definition: winternl.h:287
_RTL_USER_PROCESS_PARAMETERS::EnvironmentSize
SIZE_T EnvironmentSize
Definition: rtltypes.h:1579
_RTL_USER_PROCESS_PARAMETERS::RuntimeInfo
UNICODE_STRING RuntimeInfo
Definition: winternl.h:289
_RTL_USER_PROCESS_PARAMETERS::CurrentDirectory
CURDIR CurrentDirectory
Definition: rtltypes.h:1559
_RTL_USER_PROCESS_PARAMETERS::ImagePathName
UNICODE_STRING ImagePathName
Definition: btrfs_drv.h:1901
_RTL_USER_PROCESS_PARAMETERS::Flags
ULONG Flags
Definition: rtltypes.h:1552
_RTL_USER_PROCESS_PARAMETERS::WindowTitle
UNICODE_STRING WindowTitle
Definition: rtltypes.h:1573
_RTL_USER_PROCESS_PARAMETERS::ShellInfo
UNICODE_STRING ShellInfo
Definition: rtltypes.h:1575
_RTL_USER_PROCESS_PARAMETERS::Environment
PWSTR Environment
Definition: rtltypes.h:1563
_UNICODE_STRING
Definition: env_spec_w32.h:368
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
_UNICODE_STRING::MaximumLength
USHORT MaximumLength
Definition: env_spec_w32.h:370
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
line
Definition: parser.c:49
name
Definition: name.c:39
status
Definition: ps.c:97
test_info
Definition: dispmode.c:359
LPCSTR
const char * LPCSTR
Definition: typedefs.h:52
LPWSTR
uint16_t * LPWSTR
Definition: typedefs.h:56
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
LPDWORD
uint32_t * LPDWORD
Definition: typedefs.h:59
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
value
Definition: pdh_main.c:96
HeapSize
SIZE_T WINAPI HeapSize(HANDLE, DWORD, LPCVOID)
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
WINAPI
#define WINAPI
Definition: msvc.h:6
RtlSetCurrentEnvironment
NTSYSAPI void WINAPI RtlSetCurrentEnvironment(PWSTR, PWSTR *)
Definition: env.c:263
PROCESS_PARAMS_FLAG_NORMALIZED
#define PROCESS_PARAMS_FLAG_NORMALIZED
Definition: winternl.h:299
ERROR_ENVVAR_NOT_FOUND
#define ERROR_ENVVAR_NOT_FOUND
Definition: winerror.h:383