Merge branch 'ntfs_rebase'
[reactos.git] / modules / rostests / winetests / user32 / winstation.c
1 /*
2 * Unit tests for window stations and desktops
3 *
4 * Copyright 2002 Alexandre Julliard
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 "precomp.h"
22
23 #include <wine/winternl.h>
24
25 static NTSTATUS (WINAPI *pNtQueryObject)(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG);
26
27 #define DESKTOP_ALL_ACCESS 0x01ff
28
29 static void print_object( HANDLE obj )
30 {
31 char buffer[100];
32 DWORD size;
33
34 strcpy( buffer, "foobar" );
35 if (!GetUserObjectInformationA( obj, UOI_NAME, buffer, sizeof(buffer), &size ))
36 trace( "could not get info for %p\n", obj );
37 else
38 trace( "obj %p name '%s'\n", obj, buffer );
39 strcpy( buffer, "foobar" );
40 if (!GetUserObjectInformationA( obj, UOI_TYPE, buffer, sizeof(buffer), &size ))
41 trace( "could not get type for %p\n", obj );
42 else
43 trace( "obj %p type '%s'\n", obj, buffer );
44 }
45
46 static void register_class(void)
47 {
48 WNDCLASSA cls;
49
50 cls.style = CS_DBLCLKS;
51 cls.lpfnWndProc = DefWindowProcA;
52 cls.cbClsExtra = 0;
53 cls.cbWndExtra = 0;
54 cls.hInstance = GetModuleHandleA(0);
55 cls.hIcon = 0;
56 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
57 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
58 cls.lpszMenuName = NULL;
59 cls.lpszClassName = "WinStationClass";
60 RegisterClassA(&cls);
61 }
62
63 static HDESK initial_desktop;
64
65 static DWORD CALLBACK thread( LPVOID arg )
66 {
67 HDESK d1, d2;
68 HWND hwnd = CreateWindowExA(0,"WinStationClass","test",WS_POPUP,0,0,100,100,GetDesktopWindow(),0,0,0);
69 ok( hwnd != 0, "CreateWindow failed\n" );
70 d1 = GetThreadDesktop(GetCurrentThreadId());
71 trace( "thread %p desktop: %p\n", arg, d1 );
72 ok( d1 == initial_desktop, "thread %p doesn't use initial desktop\n", arg );
73
74 SetLastError( 0xdeadbeef );
75 ok( !CloseHandle( d1 ), "CloseHandle succeeded\n" );
76 ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
77 SetLastError( 0xdeadbeef );
78 ok( !CloseDesktop( d1 ), "CloseDesktop succeeded\n" );
79 ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */
80 "bad last error %d\n", GetLastError() );
81 print_object( d1 );
82 d2 = CreateDesktopA( "foobar2", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
83 trace( "created desktop %p\n", d2 );
84 ok( d2 != 0, "CreateDesktop failed\n" );
85
86 SetLastError( 0xdeadbeef );
87 ok( !SetThreadDesktop( d2 ), "set thread desktop succeeded with existing window\n" );
88 ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */
89 "bad last error %d\n", GetLastError() );
90
91 DestroyWindow( hwnd );
92 ok( SetThreadDesktop( d2 ), "set thread desktop failed\n" );
93 d1 = GetThreadDesktop(GetCurrentThreadId());
94 ok( d1 == d2, "GetThreadDesktop did not return set desktop %p/%p\n", d1, d2 );
95 print_object( d2 );
96 if (arg < (LPVOID)5)
97 {
98 HANDLE hthread = CreateThread( NULL, 0, thread, (char *)arg + 1, 0, NULL );
99 Sleep(1000);
100 WaitForSingleObject( hthread, INFINITE );
101 CloseHandle( hthread );
102 }
103 return 0;
104 }
105
106 static void test_handles(void)
107 {
108 HWINSTA w1, w2, w3;
109 HDESK d1, d2, d3;
110 HANDLE hthread;
111 DWORD id, flags, le;
112 ATOM atom;
113 char buffer[20];
114 DWORD size;
115 BOOL ret;
116
117 /* win stations */
118
119 w1 = GetProcessWindowStation();
120 ok( GetProcessWindowStation() == w1, "GetProcessWindowStation returned different handles\n" );
121 ok( !CloseWindowStation(w1), "closing process win station succeeded\n" );
122 SetLastError( 0xdeadbeef );
123 ok( !CloseHandle(w1), "closing process win station handle succeeded\n" );
124 ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
125 print_object( w1 );
126
127 flags = 0;
128 ok( GetHandleInformation( w1, &flags ), "GetHandleInformation failed\n" );
129 ok( !(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) ||
130 broken(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE), /* set on nt4 */
131 "handle %p PROTECT_FROM_CLOSE set\n", w1 );
132
133 ok( DuplicateHandle( GetCurrentProcess(), w1, GetCurrentProcess(), (PHANDLE)&w2, 0,
134 TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
135 ok( CloseWindowStation(w2), "closing dup win station failed\n" );
136
137 ok( DuplicateHandle( GetCurrentProcess(), w1, GetCurrentProcess(), (PHANDLE)&w2, 0,
138 TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
139 ok( CloseHandle(w2), "closing dup win station handle failed\n" );
140
141 w2 = CreateWindowStationA("WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
142 le = GetLastError();
143 ok( w2 != 0 || le == ERROR_ACCESS_DENIED, "CreateWindowStation failed (%u)\n", le );
144 if (w2 != 0)
145 {
146 ok( w2 != w1, "CreateWindowStation returned default handle\n" );
147 SetLastError( 0xdeadbeef );
148 ok( !CloseDesktop( (HDESK)w2 ), "CloseDesktop succeeded on win station\n" );
149 ok( GetLastError() == ERROR_INVALID_HANDLE || broken(GetLastError() == 0xdeadbeef), /* wow64 */
150 "bad last error %d\n", GetLastError() );
151 ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
152
153 w2 = CreateWindowStationA("WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
154 ok( CloseHandle( w2 ), "CloseHandle failed\n" );
155 }
156 else if (le == ERROR_ACCESS_DENIED)
157 win_skip( "Not enough privileges for CreateWindowStation\n" );
158
159 w2 = OpenWindowStationA("winsta0", TRUE, WINSTA_ALL_ACCESS );
160 ok( w2 != 0, "OpenWindowStation failed\n" );
161 ok( w2 != w1, "OpenWindowStation returned default handle\n" );
162 ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
163
164 w2 = OpenWindowStationA("dummy name", TRUE, WINSTA_ALL_ACCESS );
165 ok( !w2, "open dummy win station succeeded\n" );
166
167 CreateMutexA( NULL, 0, "foobar" );
168 w2 = CreateWindowStationA("foobar", 0, WINSTA_ALL_ACCESS, NULL );
169 le = GetLastError();
170 ok( w2 != 0 || le == ERROR_ACCESS_DENIED, "create foobar station failed (%u)\n", le );
171
172 if (w2 != 0)
173 {
174 w3 = OpenWindowStationA("foobar", TRUE, WINSTA_ALL_ACCESS );
175 ok( w3 != 0, "open foobar station failed\n" );
176 ok( w3 != w2, "open foobar station returned same handle\n" );
177 ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
178 ok( CloseWindowStation( w3 ), "CloseWindowStation failed\n" );
179
180 w3 = OpenWindowStationA("foobar", TRUE, WINSTA_ALL_ACCESS );
181 ok( !w3, "open foobar station succeeded\n" );
182
183 w2 = CreateWindowStationA("foobar1", 0, WINSTA_ALL_ACCESS, NULL );
184 ok( w2 != 0, "create foobar station failed\n" );
185 w3 = CreateWindowStationA("foobar2", 0, WINSTA_ALL_ACCESS, NULL );
186 ok( w3 != 0, "create foobar station failed\n" );
187 ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
188 ok( GetHandleInformation( w3, &flags ), "GetHandleInformation failed\n" );
189
190 SetProcessWindowStation( w2 );
191 atom = GlobalAddAtomA("foo");
192 ok( GlobalGetAtomNameA( atom, buffer, sizeof(buffer) ) == 3, "GlobalGetAtomName failed\n" );
193 ok( !lstrcmpiA( buffer, "foo" ), "bad atom value %s\n", buffer );
194
195 ok( !CloseWindowStation( w2 ), "CloseWindowStation succeeded\n" );
196 ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
197
198 SetProcessWindowStation( w3 );
199 ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
200 ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
201 ok( GlobalGetAtomNameA( atom, buffer, sizeof(buffer) ) == 3, "GlobalGetAtomName failed\n" );
202 ok( !lstrcmpiA( buffer, "foo" ), "bad atom value %s\n", buffer );
203 }
204 else if (le == ERROR_ACCESS_DENIED)
205 win_skip( "Not enough privileges for CreateWindowStation\n" );
206
207 SetLastError( 0xdeadbeef );
208 w2 = OpenWindowStationA( "", TRUE, WINSTA_ALL_ACCESS );
209 ok( !w2, "open station succeeded\n" );
210 todo_wine
211 ok( GetLastError() == ERROR_FILE_NOT_FOUND, "wrong error %u\n", GetLastError() );
212
213 SetLastError( 0xdeadbeef );
214 w2 = CreateWindowStationA( "", 0, WINSTA_ALL_ACCESS, NULL );
215 ok( w2 != 0, "create station failed err %u\n", GetLastError() );
216
217 memset( buffer, 0, sizeof(buffer) );
218 ret = GetUserObjectInformationA( w2, UOI_NAME, buffer, sizeof(buffer), &size );
219 ok( ret, "GetUserObjectInformationA failed with error %u\n", GetLastError() );
220 ok( !memcmp(buffer, "Service-0x0-", 12), "unexpected window station name '%s'\n", buffer );
221 ok( buffer[strlen(buffer) - 1] == '$', "unexpected window station name '%s'\n", buffer );
222
223 SetLastError( 0xdeadbeef );
224 w3 = OpenWindowStationA( "", TRUE, WINSTA_ALL_ACCESS );
225 todo_wine
226 ok( w3 != 0, "open station failed err %u\n", GetLastError() );
227 CloseWindowStation( w3 );
228 CloseWindowStation( w2 );
229
230 SetLastError( 0xdeadbeef );
231 w2 = CreateWindowStationA( "foo\\bar", 0, WINSTA_ALL_ACCESS, NULL );
232 ok( !w2, "create station succeeded\n" );
233 ok( GetLastError() == ERROR_PATH_NOT_FOUND || GetLastError() == ERROR_ACCESS_DENIED,
234 "wrong error %u\n", GetLastError() );
235
236 SetLastError( 0xdeadbeef );
237 w2 = OpenWindowStationA( "foo\\bar", TRUE, WINSTA_ALL_ACCESS );
238 ok( !w2, "create station succeeded\n" );
239 ok( GetLastError() == ERROR_PATH_NOT_FOUND, "wrong error %u\n", GetLastError() );
240
241 /* desktops */
242 d1 = GetThreadDesktop(GetCurrentThreadId());
243 initial_desktop = d1;
244 ok( GetThreadDesktop(GetCurrentThreadId()) == d1,
245 "GetThreadDesktop returned different handles\n" );
246
247 flags = 0;
248 ok( GetHandleInformation( d1, &flags ), "GetHandleInformation failed\n" );
249 ok( !(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE), "handle %p PROTECT_FROM_CLOSE set\n", d1 );
250
251 SetLastError( 0xdeadbeef );
252 ok( !CloseDesktop(d1), "closing thread desktop succeeded\n" );
253 ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */
254 "bad last error %d\n", GetLastError() );
255
256 SetLastError( 0xdeadbeef );
257 if (CloseHandle( d1 )) /* succeeds on nt4 */
258 {
259 win_skip( "NT4 desktop handle management is completely different\n" );
260 return;
261 }
262 ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
263
264 ok( DuplicateHandle( GetCurrentProcess(), d1, GetCurrentProcess(), (PHANDLE)&d2, 0,
265 TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
266 ok( CloseDesktop(d2), "closing dup desktop failed\n" );
267
268 ok( DuplicateHandle( GetCurrentProcess(), d1, GetCurrentProcess(), (PHANDLE)&d2, 0,
269 TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
270 ok( CloseHandle(d2), "closing dup desktop handle failed\n" );
271
272 d2 = OpenDesktopA( "dummy name", 0, TRUE, DESKTOP_ALL_ACCESS );
273 ok( !d2, "open dummy desktop succeeded\n" );
274
275 SetLastError( 0xdeadbeef );
276 d2 = CreateDesktopA( "", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
277 todo_wine
278 ok( !d2, "create empty desktop succeeded\n" );
279 todo_wine
280 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
281
282 SetLastError( 0xdeadbeef );
283 d2 = OpenDesktopA( "", 0, TRUE, DESKTOP_ALL_ACCESS );
284 ok( !d2, "open empty desktop succeeded\n" );
285 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
286
287 SetLastError( 0xdeadbeef );
288 d2 = CreateDesktopA( "foo\\bar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
289 ok( !d2, "create desktop succeeded\n" );
290 ok( GetLastError() == ERROR_BAD_PATHNAME, "wrong error %u\n", GetLastError() );
291
292 SetLastError( 0xdeadbeef );
293 d2 = OpenDesktopA( "foo\\bar", 0, TRUE, DESKTOP_ALL_ACCESS );
294 ok( !d2, "open desktop succeeded\n" );
295 ok( GetLastError() == ERROR_BAD_PATHNAME, "wrong error %u\n", GetLastError() );
296
297 d2 = CreateDesktopA( "foobar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
298 ok( d2 != 0, "create foobar desktop failed\n" );
299 SetLastError( 0xdeadbeef );
300 ok( !CloseWindowStation( (HWINSTA)d2 ), "CloseWindowStation succeeded on desktop\n" );
301 ok( GetLastError() == ERROR_INVALID_HANDLE || broken(GetLastError() == 0xdeadbeef), /* wow64 */
302 "bad last error %d\n", GetLastError() );
303
304 SetLastError( 0xdeadbeef );
305 d3 = CreateDesktopA( "foobar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
306 ok( d3 != 0, "create foobar desktop again failed\n" );
307 ok( GetLastError() == 0xdeadbeef, "bad last error %d\n", GetLastError() );
308 ok( CloseDesktop( d3 ), "CloseDesktop failed\n" );
309
310 d3 = OpenDesktopA( "foobar", 0, TRUE, DESKTOP_ALL_ACCESS );
311 ok( d3 != 0, "open foobar desktop failed\n" );
312 ok( d3 != d2, "open foobar desktop returned same handle\n" );
313 ok( CloseDesktop( d2 ), "CloseDesktop failed\n" );
314 ok( CloseDesktop( d3 ), "CloseDesktop failed\n" );
315
316 d3 = OpenDesktopA( "foobar", 0, TRUE, DESKTOP_ALL_ACCESS );
317 ok( !d3, "open foobar desktop succeeded\n" );
318
319 ok( !CloseHandle(d1), "closing thread desktop handle succeeded\n" );
320 d2 = GetThreadDesktop(GetCurrentThreadId());
321 ok( d1 == d2, "got different handles after close\n" );
322
323 register_class();
324 trace( "thread 1 desktop: %p\n", d1 );
325 print_object( d1 );
326 hthread = CreateThread( NULL, 0, thread, (LPVOID)2, 0, &id );
327 Sleep(1000);
328 trace( "get other thread desktop: %p\n", GetThreadDesktop(id) );
329 WaitForSingleObject( hthread, INFINITE );
330 CloseHandle( hthread );
331
332 /* clean side effect */
333 SetProcessWindowStation( w1 );
334 }
335
336 /* Enumeration tests */
337
338 static BOOL CALLBACK window_station_callbackA(LPSTR winsta, LPARAM lp)
339 {
340 trace("window_station_callbackA called with argument %s\n", winsta);
341 return lp;
342 }
343
344 static BOOL CALLBACK open_window_station_callbackA(LPSTR winsta, LPARAM lp)
345 {
346 HWINSTA hwinsta;
347
348 trace("open_window_station_callbackA called with argument %s\n", winsta);
349 hwinsta = OpenWindowStationA(winsta, FALSE, WINSTA_ENUMERATE);
350 ok(hwinsta != NULL, "Could not open desktop %s!\n", winsta);
351 if (hwinsta)
352 CloseWindowStation(hwinsta);
353 return lp;
354 }
355
356 static void test_enumstations(void)
357 {
358 DWORD ret;
359 HWINSTA hwinsta;
360
361 if (0) /* Crashes instead */
362 {
363 SetLastError(0xbabefeed);
364 ret = EnumWindowStationsA(NULL, 0);
365 ok(!ret, "EnumWindowStationsA returned successfully!\n");
366 ok(GetLastError() == ERROR_INVALID_PARAMETER, "LastError is set to %08x\n", GetLastError());
367 }
368
369 hwinsta = CreateWindowStationA("winsta_test", 0, WINSTA_ALL_ACCESS, NULL);
370 ret = GetLastError();
371 ok(hwinsta != NULL || ret == ERROR_ACCESS_DENIED, "CreateWindowStation failed (%u)\n", ret);
372 if (!hwinsta)
373 {
374 win_skip("Not enough privileges for CreateWindowStation\n");
375 return;
376 }
377
378 SetLastError(0xdeadbeef);
379 ret = EnumWindowStationsA(open_window_station_callbackA, 0x12345);
380 ok(ret == 0x12345, "EnumWindowStationsA returned %x\n", ret);
381 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
382
383 SetLastError(0xdeadbeef);
384 ret = EnumWindowStationsA(window_station_callbackA, 0);
385 ok(!ret, "EnumWindowStationsA returned %x\n", ret);
386 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
387 }
388
389 static BOOL CALLBACK desktop_callbackA(LPSTR desktop, LPARAM lp)
390 {
391 trace("desktop_callbackA called with argument %s\n", desktop);
392 return lp;
393 }
394
395 static BOOL CALLBACK open_desktop_callbackA(LPSTR desktop, LPARAM lp)
396 {
397 HDESK hdesk;
398 static int once;
399
400 trace("open_desktop_callbackA called with argument %s\n", desktop);
401 /* Only try to open one desktop */
402 if (once++)
403 return lp;
404
405 hdesk = OpenDesktopA(desktop, 0, FALSE, DESKTOP_ENUMERATE);
406 ok(hdesk != NULL, "Could not open desktop %s!\n", desktop);
407 if (hdesk)
408 CloseDesktop(hdesk);
409 return lp;
410 }
411
412 static void test_enumdesktops(void)
413 {
414 BOOL ret;
415
416 if (0) /* Crashes instead */
417 {
418 SetLastError(0xbabefeed);
419 ret = EnumDesktopsA(GetProcessWindowStation(), NULL, 0);
420 ok(!ret, "EnumDesktopsA returned successfully!\n");
421 ok(GetLastError() == ERROR_INVALID_PARAMETER, "LastError is set to %08x\n", GetLastError());
422 }
423
424 SetLastError(0xdeadbeef);
425 ret = EnumDesktopsA(NULL, desktop_callbackA, 0x12345);
426 ok(ret == 0x12345, "EnumDesktopsA returned %x\n", ret);
427 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
428
429 SetLastError(0xdeadbeef);
430 ret = EnumDesktopsA(GetProcessWindowStation(), open_desktop_callbackA, 0x12345);
431 ok(ret == 0x12345, "EnumDesktopsA returned %x\n", ret);
432 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
433
434 SetLastError(0xdeadbeef);
435 ret = EnumDesktopsA(INVALID_HANDLE_VALUE, desktop_callbackA, 0x12345);
436 ok(!ret, "EnumDesktopsA returned %x\n", ret);
437 ok(GetLastError() == ERROR_INVALID_HANDLE, "LastError is set to %08x\n", GetLastError());
438
439 SetLastError(0xdeadbeef);
440 ret = EnumDesktopsA(GetProcessWindowStation(), desktop_callbackA, 0);
441 ok(!ret, "EnumDesktopsA returned %x\n", ret);
442 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
443 }
444
445 /* Miscellaneous tests */
446
447 static void test_getuserobjectinformation(void)
448 {
449 WCHAR foobarTestW[] = {'\\','f','o','o','b','a','r','T','e','s','t',0};
450 WCHAR DesktopW[] = {'D','e','s','k','t','o','p',0};
451 OBJECT_NAME_INFORMATION *name_info;
452 WCHAR bufferW[20];
453 char buffer[64];
454 NTSTATUS status;
455 DWORD size;
456 HDESK desk;
457 BOOL ret;
458
459 desk = CreateDesktopA("foobarTest", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL);
460 ok(desk != 0, "open foobarTest desktop failed\n");
461
462 strcpy(buffer, "blahblah");
463
464 /** Tests for UOI_NAME **/
465
466 /* Get size, test size and return value/error code */
467 SetLastError(0xdeadbeef);
468 size = 0xdeadbeef;
469 ret = GetUserObjectInformationA(desk, UOI_NAME, NULL, 0, &size);
470
471 ok(!ret, "GetUserObjectInformationA returned %x\n", ret);
472 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "LastError is set to %08x\n", GetLastError());
473 ok(size == 22, "size is set to %d\n", size); /* Windows returns Unicode length (11*2) */
474
475 /* Get string */
476 SetLastError(0xdeadbeef);
477 size = 0xdeadbeef;
478 ret = GetUserObjectInformationA(desk, UOI_NAME, buffer, sizeof(buffer), &size);
479
480 ok(ret, "GetUserObjectInformationA returned %x\n", ret);
481 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
482
483 ok(strcmp(buffer, "foobarTest") == 0, "Buffer is set to '%s'\n", buffer);
484 ok(size == 11, "size is set to %d\n", size); /* 11 bytes in 'foobarTest\0' */
485
486 /* Get size, test size and return value/error code (Unicode) */
487 SetLastError(0xdeadbeef);
488 size = 0xdeadbeef;
489 ret = GetUserObjectInformationW(desk, UOI_NAME, NULL, 0, &size);
490
491 ok(!ret, "GetUserObjectInformationW returned %x\n", ret);
492 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "LastError is set to %08x\n", GetLastError());
493 ok(size == 22, "size is set to %d\n", size); /* 22 bytes in 'foobarTest\0' in Unicode */
494
495 /* Get string (Unicode) */
496 SetLastError(0xdeadbeef);
497 size = 0xdeadbeef;
498 ret = GetUserObjectInformationW(desk, UOI_NAME, bufferW, sizeof(bufferW), &size);
499
500 ok(ret, "GetUserObjectInformationW returned %x\n", ret);
501 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
502
503 ok(lstrcmpW(bufferW, foobarTestW + 1) == 0, "Buffer is not set to 'foobarTest'\n");
504 ok(size == 22, "size is set to %d\n", size); /* 22 bytes in 'foobarTest\0' in Unicode */
505
506 /* ObjectNameInformation does not return the full desktop name */
507 name_info = (OBJECT_NAME_INFORMATION *)buffer;
508 status = pNtQueryObject(desk, ObjectNameInformation, name_info, sizeof(buffer), NULL);
509 ok(!status, "expected STATUS_SUCCESS, got %08x\n", status);
510 ok(lstrcmpW(name_info->Name.Buffer, foobarTestW) == 0,
511 "expected '\\foobarTest', got %s\n", wine_dbgstr_w(name_info->Name.Buffer));
512
513 /** Tests for UOI_TYPE **/
514
515 /* Get size, test size and return value/error code */
516 SetLastError(0xdeadbeef);
517 size = 0xdeadbeef;
518 ret = GetUserObjectInformationA(desk, UOI_TYPE, NULL, 0, &size);
519
520 ok(!ret, "GetUserObjectInformationA returned %x\n", ret);
521 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "LastError is set to %08x\n", GetLastError());
522 ok(size == 16, "size is set to %d\n", size); /* Windows returns Unicode length (8*2) */
523
524 /* Get string */
525 SetLastError(0xdeadbeef);
526 size = 0xdeadbeef;
527 ret = GetUserObjectInformationA(desk, UOI_TYPE, buffer, sizeof(buffer), &size);
528
529 ok(ret, "GetUserObjectInformationA returned %x\n", ret);
530 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
531
532 ok(strcmp(buffer, "Desktop") == 0, "Buffer is set to '%s'\n", buffer);
533 ok(size == 8, "size is set to %d\n", size); /* 8 bytes in 'Desktop\0' */
534
535 /* Get size, test size and return value/error code (Unicode) */
536 size = 0xdeadbeef;
537 SetLastError(0xdeadbeef);
538 ret = GetUserObjectInformationW(desk, UOI_TYPE, NULL, 0, &size);
539
540 ok(!ret, "GetUserObjectInformationW returned %x\n", ret);
541 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "LastError is set to %08x\n", GetLastError());
542 ok(size == 16, "size is set to %d\n", size); /* 16 bytes in 'Desktop\0' in Unicode */
543
544 /* Get string (Unicode) */
545 SetLastError(0xdeadbeef);
546 size = 0xdeadbeef;
547 ret = GetUserObjectInformationW(desk, UOI_TYPE, bufferW, sizeof(bufferW), &size);
548
549 ok(ret, "GetUserObjectInformationW returned %x\n", ret);
550 ok(GetLastError() == 0xdeadbeef, "LastError is set to %08x\n", GetLastError());
551
552 ok(lstrcmpW(bufferW, DesktopW) == 0, "Buffer is not set to 'Desktop'\n");
553 ok(size == 16, "size is set to %d\n", size); /* 16 bytes in 'Desktop\0' in Unicode */
554
555 ok(CloseDesktop(desk), "CloseDesktop failed\n");
556 }
557
558 static void test_inputdesktop(void)
559 {
560 HDESK input_desk, old_input_desk, thread_desk, old_thread_desk, new_desk;
561 DWORD ret;
562 CHAR name[1024];
563 INPUT inputs[1];
564
565 inputs[0].type = INPUT_KEYBOARD;
566 U(inputs[0]).ki.wVk = 0;
567 U(inputs[0]).ki.wScan = 0x3c0;
568 U(inputs[0]).ki.dwFlags = KEYEVENTF_UNICODE;
569
570 /* OpenInputDesktop creates new handles for each calls */
571 old_input_desk = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
572 ok(old_input_desk != NULL, "OpenInputDesktop failed!\n");
573 memset(name, 0, sizeof(name));
574 ret = GetUserObjectInformationA(old_input_desk, UOI_NAME, name, 1024, NULL);
575 ok(ret, "GetUserObjectInformation failed!\n");
576 ok(!strcmp(name, "Default"), "unexpected desktop %s\n", name);
577
578 input_desk = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
579 ok(input_desk != NULL, "OpenInputDesktop failed!\n");
580 memset(name, 0, sizeof(name));
581 ret = GetUserObjectInformationA(input_desk, UOI_NAME, name, 1024, NULL);
582 ok(ret, "GetUserObjectInformation failed!\n");
583 ok(!strcmp(name, "Default"), "unexpected desktop %s\n", name);
584
585 ok(old_input_desk != input_desk, "returned the same handle!\n");
586 ret = CloseDesktop(input_desk);
587 ok(ret, "CloseDesktop failed!\n");
588
589 /* by default, GetThreadDesktop is the input desktop, SendInput should succeed. */
590 old_thread_desk = GetThreadDesktop(GetCurrentThreadId());
591 ok(old_thread_desk != NULL, "GetThreadDesktop faile!\n");
592 memset(name, 0, sizeof(name));
593 ret = GetUserObjectInformationA(old_thread_desk, UOI_NAME, name, 1024, NULL);
594 ok(!strcmp(name, "Default"), "unexpected desktop %s\n", name);
595
596 SetLastError(0xdeadbeef);
597 ret = SendInput(1, inputs, sizeof(INPUT));
598 ok(GetLastError() == 0xdeadbeef, "unexpected last error %08x\n", GetLastError());
599 ok(ret == 1, "unexpected return count %d\n", ret);
600
601 /* Set thread desktop to the new desktop, SendInput should fail. */
602 new_desk = CreateDesktopA("new_desk", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL);
603 ok(new_desk != NULL, "CreateDesktop failed!\n");
604 ret = SetThreadDesktop(new_desk);
605 ok(ret, "SetThreadDesktop failed!\n");
606 thread_desk = GetThreadDesktop(GetCurrentThreadId());
607 ok(thread_desk == new_desk, "thread desktop doesn't match!\n");
608 memset(name, 0, sizeof(name));
609 ret = GetUserObjectInformationA(thread_desk, UOI_NAME, name, 1024, NULL);
610 ok(!strcmp(name, "new_desk"), "unexpected desktop %s\n", name);
611
612 SetLastError(0xdeadbeef);
613 ret = SendInput(1, inputs, sizeof(INPUT));
614 if(broken(GetLastError() == 0xdeadbeef))
615 {
616 SetThreadDesktop(old_thread_desk);
617 CloseDesktop(old_input_desk);
618 CloseDesktop(input_desk);
619 CloseDesktop(new_desk);
620 win_skip("Skip tests on NT4\n");
621 return;
622 }
623 todo_wine
624 ok(GetLastError() == ERROR_ACCESS_DENIED, "unexpected last error %08x\n", GetLastError());
625 ok(ret == 1 || broken(ret == 0) /* Win64 */, "unexpected return count %d\n", ret);
626
627 /* Set thread desktop back to the old thread desktop, SendInput should success. */
628 ret = SetThreadDesktop(old_thread_desk);
629 ok(ret, "SetThreadDesktop failed!\n");
630 thread_desk = GetThreadDesktop(GetCurrentThreadId());
631 ok(thread_desk == old_thread_desk, "thread desktop doesn't match!\n");
632 memset(name, 0, sizeof(name));
633 ret = GetUserObjectInformationA(thread_desk, UOI_NAME, name, 1024, NULL);
634 ok(!strcmp(name, "Default"), "unexpected desktop %s\n", name);
635
636 SetLastError(0xdeadbeef);
637 ret = SendInput(1, inputs, sizeof(INPUT));
638 ok(GetLastError() == 0xdeadbeef, "unexpected last error %08x\n", GetLastError());
639 ok(ret == 1, "unexpected return count %d\n", ret);
640
641 /* Set thread desktop to the input desktop, SendInput should success. */
642 ret = SetThreadDesktop(old_input_desk);
643 ok(ret, "SetThreadDesktop failed!\n");
644 thread_desk = GetThreadDesktop(GetCurrentThreadId());
645 ok(thread_desk == old_input_desk, "thread desktop doesn't match!\n");
646 memset(name, 0, sizeof(name));
647 ret = GetUserObjectInformationA(thread_desk, UOI_NAME, name, 1024, NULL);
648 ok(!strcmp(name, "Default"), "unexpected desktop %s\n", name);
649
650 SetLastError(0xdeadbeef);
651 ret = SendInput(1, inputs, sizeof(INPUT));
652 ok(GetLastError() == 0xdeadbeef, "unexpected last error %08x\n", GetLastError());
653 ok(ret == 1, "unexpected return count %d\n", ret);
654
655 /* Switch input desktop to the new desktop, SendInput should fail. */
656 ret = SwitchDesktop(new_desk);
657 ok(ret, "SwitchDesktop failed!\n");
658 input_desk = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
659 ok(input_desk != NULL, "OpenInputDesktop failed!\n");
660 ok(input_desk != new_desk, "returned the same handle!\n");
661 memset(name, 0, sizeof(name));
662 ret = GetUserObjectInformationA(input_desk, UOI_NAME, name, 1024, NULL);
663 ok(ret, "GetUserObjectInformation failed!\n");
664 todo_wine
665 ok(!strcmp(name, "new_desk"), "unexpected desktop %s\n", name);
666 ret = CloseDesktop(input_desk);
667 ok(ret, "CloseDesktop failed!\n");
668
669 SetLastError(0xdeadbeef);
670 ret = SendInput(1, inputs, sizeof(INPUT));
671 todo_wine
672 ok(GetLastError() == ERROR_ACCESS_DENIED, "unexpected last error %08x\n", GetLastError());
673 ok(ret == 1 || broken(ret == 0) /* Win64 */, "unexpected return count %d\n", ret);
674
675 /* Set thread desktop to the new desktop, SendInput should success. */
676 ret = SetThreadDesktop(new_desk);
677 ok(ret, "SetThreadDesktop failed!\n");
678 thread_desk = GetThreadDesktop(GetCurrentThreadId());
679 ok(thread_desk == new_desk, "thread desktop doesn't match!\n");
680 memset(name, 0, sizeof(name));
681 ret = GetUserObjectInformationA(thread_desk, UOI_NAME, name, 1024, NULL);
682 ok(!strcmp(name, "new_desk"), "unexpected desktop %s\n", name);
683
684 SetLastError(0xdeadbeef);
685 ret = SendInput(1, inputs, sizeof(INPUT));
686 ok(GetLastError() == 0xdeadbeef, "unexpected last error %08x\n", GetLastError());
687 ok(ret == 1, "unexpected return count %d\n", ret);
688
689 /* Switch input desktop to the old input desktop, set thread desktop to the old
690 * thread desktop, clean side effects. SendInput should success. */
691 ret = SwitchDesktop(old_input_desk);
692 input_desk = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
693 ok(input_desk != NULL, "OpenInputDesktop failed!\n");
694 ok(input_desk != old_input_desk, "returned the same handle!\n");
695 memset(name, 0, sizeof(name));
696 ret = GetUserObjectInformationA(input_desk, UOI_NAME, name, 1024, NULL);
697 ok(ret, "GetUserObjectInformation failed!\n");
698 ok(!strcmp(name, "Default"), "unexpected desktop %s\n", name);
699
700 ret = SetThreadDesktop(old_thread_desk);
701 ok(ret, "SetThreadDesktop failed!\n");
702 thread_desk = GetThreadDesktop(GetCurrentThreadId());
703 ok(thread_desk == old_thread_desk, "thread desktop doesn't match!\n");
704 memset(name, 0, sizeof(name));
705 ret = GetUserObjectInformationA(thread_desk, UOI_NAME, name, 1024, NULL);
706 ok(!strcmp(name, "Default"), "unexpected desktop %s\n", name);
707
708 SetLastError(0xdeadbeef);
709 ret = SendInput(1, inputs, sizeof(INPUT));
710 ok(GetLastError() == 0xdeadbeef, "unexpected last error %08x\n", GetLastError());
711 ok(ret == 1, "unexpected return count %d\n", ret);
712
713 /* free resources */
714 ret = CloseDesktop(input_desk);
715 ok(ret, "CloseDesktop failed!\n");
716 ret = CloseDesktop(old_input_desk);
717 ok(ret, "CloseDesktop failed!\n");
718 ret = CloseDesktop(new_desk);
719 ok(ret, "CloseDesktop failed!\n");
720 }
721
722 static void test_inputdesktop2(void)
723 {
724 HWINSTA w1, w2;
725 HDESK thread_desk, new_desk, input_desk, hdesk;
726 DWORD ret;
727
728 thread_desk = GetThreadDesktop(GetCurrentThreadId());
729 ok(thread_desk != NULL, "GetThreadDesktop failed!\n");
730 w1 = GetProcessWindowStation();
731 ok(w1 != NULL, "GetProcessWindowStation failed!\n");
732 SetLastError(0xdeadbeef);
733 w2 = CreateWindowStationA("winsta_test", 0, WINSTA_ALL_ACCESS, NULL);
734 ret = GetLastError();
735 ok(w2 != NULL || ret == ERROR_ACCESS_DENIED, "CreateWindowStation failed (%u)\n", ret);
736 if (!w2)
737 {
738 win_skip("Not enough privileges for CreateWindowStation\n");
739 return;
740 }
741
742 ret = EnumDesktopsA(GetProcessWindowStation(), desktop_callbackA, 0);
743 ok(!ret, "EnumDesktopsA failed!\n");
744 input_desk = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
745 ok(input_desk != NULL, "OpenInputDesktop failed!\n");
746 ret = CloseDesktop(input_desk);
747 ok(ret, "CloseDesktop failed!\n");
748
749 ret = SetProcessWindowStation(w2);
750 ok(ret, "SetProcessWindowStation failed!\n");
751 hdesk = GetThreadDesktop(GetCurrentThreadId());
752 ok(hdesk != NULL, "GetThreadDesktop failed!\n");
753 ok(hdesk == thread_desk, "thread desktop should not change after winstation changed!\n");
754 ret = EnumDesktopsA(GetProcessWindowStation(), desktop_callbackA, 0);
755
756 new_desk = CreateDesktopA("desk_test", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL);
757 ok(new_desk != NULL, "CreateDesktop failed!\n");
758 ret = EnumDesktopsA(GetProcessWindowStation(), desktop_callbackA, 0);
759 ok(!ret, "EnumDesktopsA failed!\n");
760 SetLastError(0xdeadbeef);
761 input_desk = OpenInputDesktop(0, FALSE, DESKTOP_ALL_ACCESS);
762 ok(input_desk == NULL, "OpenInputDesktop should fail on non default winstation!\n");
763 ok(GetLastError() == ERROR_INVALID_FUNCTION || broken(GetLastError() == 0xdeadbeef), "last error %08x\n", GetLastError());
764
765 hdesk = OpenDesktopA("desk_test", 0, TRUE, DESKTOP_ALL_ACCESS);
766 ok(hdesk != NULL, "OpenDesktop failed!\n");
767 SetLastError(0xdeadbeef);
768 ret = SwitchDesktop(hdesk);
769 todo_wine
770 ok(!ret, "Switch to desktop belong to non default winstation should fail!\n");
771 todo_wine
772 ok(GetLastError() == ERROR_ACCESS_DENIED || broken(GetLastError() == 0xdeadbeef), "last error %08x\n", GetLastError());
773 ret = SetThreadDesktop(hdesk);
774 ok(ret, "SetThreadDesktop failed!\n");
775
776 /* clean side effect */
777 ret = SetThreadDesktop(thread_desk);
778 todo_wine
779 ok(ret, "SetThreadDesktop should success even desktop is not belong to process winstation!\n");
780 ret = SetProcessWindowStation(w1);
781 ok(ret, "SetProcessWindowStation failed!\n");
782 ret = SetThreadDesktop(thread_desk);
783 ok(ret, "SetThreadDesktop failed!\n");
784 ret = CloseWindowStation(w2);
785 ok(ret, "CloseWindowStation failed!\n");
786 ret = CloseDesktop(new_desk);
787 ok(ret, "CloseDesktop failed!\n");
788 ret = CloseDesktop(hdesk);
789 ok(ret, "CloseDesktop failed!\n");
790 }
791
792 static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
793 {
794 if (msg == WM_DESTROY)
795 {
796 trace("destroying hwnd %p\n", hWnd);
797 PostQuitMessage(0);
798 return 0;
799 }
800 return DefWindowProcA( hWnd, msg, wParam, lParam );
801 }
802
803 typedef struct tag_wnd_param
804 {
805 const char *wnd_name;
806 HWND hwnd;
807 HDESK hdesk;
808 HANDLE hevent;
809 } wnd_param;
810
811 static DWORD WINAPI create_window(LPVOID param)
812 {
813 wnd_param *param1 = param;
814 DWORD ret;
815 MSG msg;
816
817 ret = SetThreadDesktop(param1->hdesk);
818 ok(ret, "SetThreadDesktop failed!\n");
819 param1->hwnd = CreateWindowA("test_class", param1->wnd_name, WS_POPUP, 0, 0, 100, 100, NULL, NULL, NULL, NULL);
820 ok(param1->hwnd != 0, "CreateWindowA failed!\n");
821 ret = SetEvent(param1->hevent);
822 ok(ret, "SetEvent failed!\n");
823
824 while (GetMessageA(&msg, 0, 0, 0))
825 {
826 TranslateMessage(&msg);
827 DispatchMessageA(&msg);
828 }
829
830 return 0;
831 }
832
833 static DWORD set_foreground(HWND hwnd)
834 {
835 HWND hwnd_fore;
836 DWORD set_id, fore_id, ret;
837 char win_text[1024];
838
839 hwnd_fore = GetForegroundWindow();
840 GetWindowTextA(hwnd_fore, win_text, 1024);
841 set_id = GetWindowThreadProcessId(hwnd, NULL);
842 fore_id = GetWindowThreadProcessId(hwnd_fore, NULL);
843 trace("\"%s\" %p %08x hwnd %p %08x\n", win_text, hwnd_fore, fore_id, hwnd, set_id);
844 ret = AttachThreadInput(set_id, fore_id, TRUE);
845 trace("AttachThreadInput returned %08x\n", ret);
846 ret = ShowWindow(hwnd, SW_SHOWNORMAL);
847 trace("ShowWindow returned %08x\n", ret);
848 ret = SetWindowPos(hwnd, HWND_TOPMOST, 0,0,0,0, SWP_NOSIZE|SWP_NOMOVE);
849 trace("set topmost returned %08x\n", ret);
850 ret = SetWindowPos(hwnd, HWND_NOTOPMOST, 0,0,0,0, SWP_NOSIZE|SWP_NOMOVE);
851 trace("set notopmost returned %08x\n", ret);
852 ret = SetForegroundWindow(hwnd);
853 trace("SetForegroundWindow returned %08x\n", ret);
854 Sleep(250);
855 AttachThreadInput(set_id, fore_id, FALSE);
856 return ret;
857 }
858
859 static void test_foregroundwindow(void)
860 {
861 HWND hwnd, hwnd_test, partners[2], hwnds[2];
862 HDESK hdesks[2];
863 int thread_desk_id, input_desk_id, hwnd_id;
864 WNDCLASSA wclass;
865 wnd_param param;
866 DWORD ret, timeout, timeout_old;
867 char win_text[1024];
868
869 #define DESKTOPS 2
870
871 memset( &wclass, 0, sizeof(wclass) );
872 wclass.lpszClassName = "test_class";
873 wclass.lpfnWndProc = WndProc;
874 RegisterClassA(&wclass);
875 param.wnd_name = "win_name";
876
877 hdesks[0] = GetThreadDesktop(GetCurrentThreadId());
878 ok(hdesks[0] != NULL, "OpenDesktop failed!\n");
879 SetLastError(0xdeadbeef);
880 hdesks[1] = CreateDesktopA("desk2", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL);
881 ret = GetLastError();
882 ok(hdesks[1] != NULL || ret == ERROR_ACCESS_DENIED, "CreateDesktop failed (%u)\n", ret);
883 if(!hdesks[1])
884 {
885 win_skip("Not enough privileges for CreateDesktop\n");
886 return;
887 }
888
889 ret = SystemParametersInfoA(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, &timeout_old, 0);
890 if(!ret)
891 {
892 win_skip("Skip tests on NT4\n");
893 CloseDesktop(hdesks[1]);
894 return;
895 }
896 trace("old timeout %d\n", timeout_old);
897 timeout = 0;
898 ret = SystemParametersInfoA(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, 0, SPIF_SENDCHANGE | SPIF_UPDATEINIFILE);
899 ok(ret, "set foreground lock timeout failed!\n");
900 ret = SystemParametersInfoA(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, &timeout, 0);
901 ok(ret, "get foreground lock timeout failed!\n");
902 ok(timeout == 0, "unexpected timeout %d\n", timeout);
903
904 for (thread_desk_id = 0; thread_desk_id < DESKTOPS; thread_desk_id++)
905 {
906 param.hdesk = hdesks[thread_desk_id];
907 param.hevent = CreateEventA(NULL, TRUE, FALSE, NULL);
908 CreateThread(NULL, 0, create_window, &param, 0, NULL);
909 ret = WaitForSingleObject(param.hevent, INFINITE);
910 ok(ret == WAIT_OBJECT_0, "wait failed!\n");
911 hwnds[thread_desk_id] = param.hwnd;
912 }
913
914 for (thread_desk_id = 0; thread_desk_id < DESKTOPS; thread_desk_id++)
915 {
916 param.hdesk = hdesks[thread_desk_id];
917 param.hevent = CreateEventA(NULL, TRUE, FALSE, NULL);
918 CreateThread(NULL, 0, create_window, &param, 0, NULL);
919 ret = WaitForSingleObject(param.hevent, INFINITE);
920 ok(ret == WAIT_OBJECT_0, "wait failed!\n");
921 partners[thread_desk_id] = param.hwnd;
922 }
923
924 trace("hwnd0 %p hwnd1 %p partner0 %p partner1 %p\n", hwnds[0], hwnds[1], partners[0], partners[1]);
925
926 for (hwnd_id = 0; hwnd_id < DESKTOPS; hwnd_id++)
927 for (thread_desk_id = 0; thread_desk_id < DESKTOPS; thread_desk_id++)
928 for (input_desk_id = 0; input_desk_id < DESKTOPS; input_desk_id++)
929 {
930 trace("testing thread_desk %d input_desk %d hwnd %d\n",
931 thread_desk_id, input_desk_id, hwnd_id);
932 hwnd_test = hwnds[hwnd_id];
933 ret = SetThreadDesktop(hdesks[thread_desk_id]);
934 ok(ret, "set thread desktop failed!\n");
935 ret = SwitchDesktop(hdesks[input_desk_id]);
936 ok(ret, "switch desktop failed!\n");
937 set_foreground(partners[0]);
938 set_foreground(partners[1]);
939 hwnd = GetForegroundWindow();
940 ok(hwnd != hwnd_test, "unexpected foreground window %p\n", hwnd);
941 ret = set_foreground(hwnd_test);
942 hwnd = GetForegroundWindow();
943 GetWindowTextA(hwnd, win_text, 1024);
944 trace("hwnd %p name %s\n", hwnd, win_text);
945 if (input_desk_id == hwnd_id)
946 {
947 if (input_desk_id == thread_desk_id)
948 {
949 ok(ret, "SetForegroundWindow failed!\n");
950 todo_wine_if (!hwnd)
951 ok(hwnd == hwnd_test , "unexpected foreground window %p\n", hwnd);
952 }
953 else
954 {
955 todo_wine ok(ret, "SetForegroundWindow failed!\n");
956 todo_wine ok(hwnd == 0, "unexpected foreground window %p\n", hwnd);
957 }
958 }
959 else
960 {
961 if (input_desk_id == thread_desk_id)
962 {
963 ok(!ret, "SetForegroundWindow should fail!\n");
964 todo_wine_if (!hwnd)
965 ok(hwnd == partners[input_desk_id] , "unexpected foreground window %p\n", hwnd);
966 }
967 else
968 {
969 todo_wine ok(!ret, "SetForegroundWindow should fail!\n");
970 todo_wine_if (hwnd)
971 ok(hwnd == 0, "unexpected foreground window %p\n", hwnd);
972 }
973 }
974 }
975
976 /* Clean up */
977
978 for (thread_desk_id = DESKTOPS - 1; thread_desk_id >= 0; thread_desk_id--)
979 {
980 ret = SetThreadDesktop(hdesks[thread_desk_id]);
981 ok(ret, "set thread desktop failed!\n");
982 SendMessageA(hwnds[thread_desk_id], WM_DESTROY, 0, 0);
983 SendMessageA(partners[thread_desk_id], WM_DESTROY, 0, 0);
984 }
985
986 ret = SwitchDesktop(hdesks[0]);
987 ok(ret, "switch desktop failed!\n");
988 CloseDesktop(hdesks[1]);
989
990 ret = SystemParametersInfoA(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, UlongToPtr(timeout_old), SPIF_SENDCHANGE | SPIF_UPDATEINIFILE);
991 ok(ret, "set foreground lock timeout failed!\n");
992 ret = SystemParametersInfoA(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, &timeout, 0);
993 ok(ret, "get foreground lock timeout failed!\n");
994 ok(timeout == timeout_old, "unexpected timeout %d\n", timeout);
995 }
996
997 START_TEST(winstation)
998 {
999 HMODULE hntdll = GetModuleHandleA("ntdll.dll");
1000 pNtQueryObject = (void *)GetProcAddress(hntdll, "NtQueryObject");
1001
1002 /* Check whether this platform supports WindowStation calls */
1003
1004 SetLastError( 0xdeadbeef );
1005 GetProcessWindowStation();
1006 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1007 {
1008 win_skip("WindowStation calls not supported on this platform\n");
1009 return;
1010 }
1011
1012 test_inputdesktop();
1013 test_inputdesktop2();
1014 test_enumstations();
1015 test_enumdesktops();
1016 test_handles();
1017 test_getuserobjectinformation();
1018 test_foregroundwindow();
1019 }