ntdll/tests: Skip tests if NtCurrentTeb doesn't exist.
[wine] / dlls / ntdll / tests / atom.c
1 /* Unit test suite for Ntdll atom API functions
2  *
3  * Copyright 2003 Gyorgy 'Nog' Jeney
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  * NOTES
20  * We use function pointers here as there is no import library for NTDLL on
21  * windows.
22  */
23
24 #include <stdio.h>
25 #include <stdarg.h>
26
27 #include "ntstatus.h"
28 /* Define WIN32_NO_STATUS so MSVC does not give us duplicate macro 
29  * definition errors when we get to winnt.h
30  */
31 #define WIN32_NO_STATUS
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "winreg.h"
36 #include "winnls.h"
37 #include "wine/test.h"
38 #include "wine/unicode.h"
39 #include "winternl.h"
40
41 #ifndef __WINE_WINTERNL_H
42 typedef unsigned short RTL_ATOM, *PRTL_ATOM;
43 typedef struct atom_table *RTL_ATOM_TABLE, **PRTL_ATOM_TABLE;
44 #endif
45
46 /* Function pointers for ntdll calls */
47 static HMODULE hntdll = 0;
48 static NTSTATUS (WINAPI *pRtlCreateAtomTable)(ULONG,PRTL_ATOM_TABLE);
49 static NTSTATUS (WINAPI *pRtlDestroyAtomTable)(RTL_ATOM_TABLE);
50 static NTSTATUS (WINAPI *pRtlEmptyAtomTable)(RTL_ATOM_TABLE,BOOLEAN);
51 static NTSTATUS (WINAPI *pRtlAddAtomToAtomTable)(RTL_ATOM_TABLE,PCWSTR,PRTL_ATOM);
52 static NTSTATUS (WINAPI *pRtlDeleteAtomFromAtomTable)(RTL_ATOM_TABLE,RTL_ATOM);
53 static NTSTATUS (WINAPI *pRtlLookupAtomInAtomTable)(RTL_ATOM_TABLE,PCWSTR,PRTL_ATOM);
54 static NTSTATUS (WINAPI *pRtlPinAtomInAtomTable)(RTL_ATOM_TABLE,RTL_ATOM);
55 static NTSTATUS (WINAPI *pRtlQueryAtomInAtomTable)(RTL_ATOM_TABLE,RTL_ATOM,PULONG,PULONG,PWSTR,PULONG);
56
57 static NTSTATUS (WINAPI* pNtAddAtom)(LPCWSTR,ULONG,RTL_ATOM*);
58 static NTSTATUS (WINAPI* pNtQueryInformationAtom)(RTL_ATOM,DWORD,void*,ULONG,PULONG);
59
60 static const WCHAR EmptyAtom[] = {0};
61 static const WCHAR testAtom1[] = {'H','e','l','l','o',' ','W','o','r','l','d',0};
62 static const WCHAR testAtom2[] = {'H','e','l','l','o',' ','W','o','r','l','d','2',0};
63 static const WCHAR testAtom3[] = {'H','e','l','l','o',' ','W','o','r','l','d','3',0};
64
65 static const WCHAR testAtom1Cap[] = {'H','E','L','L','O',' ','W','O','R','L','D',0};
66 static const WCHAR testAtom1Low[] = {'h','e','l','l','o',' ','w','o','r','l','d',0};
67
68 static const WCHAR testAtomInt[] = {'#','1','3','2',0};
69 static const WCHAR testAtomIntInv[] = {'#','2','3','4','z',0};
70 static const WCHAR testAtomOTT[] = {'#','1','2','3',0};
71
72 static void InitFunctionPtr(void)
73 {
74     hntdll = LoadLibraryA("ntdll.dll");
75     ok(hntdll != 0, "Unable to load ntdll.dll\n");
76
77     if (hntdll)
78     {
79         pRtlCreateAtomTable = (void *)GetProcAddress(hntdll, "RtlCreateAtomTable");
80         pRtlDestroyAtomTable = (void *)GetProcAddress(hntdll, "RtlDestroyAtomTable");
81         pRtlEmptyAtomTable = (void *)GetProcAddress(hntdll, "RtlEmptyAtomTable");
82         pRtlAddAtomToAtomTable = (void *)GetProcAddress(hntdll, "RtlAddAtomToAtomTable");
83         pRtlDeleteAtomFromAtomTable = (void *)GetProcAddress(hntdll, "RtlDeleteAtomFromAtomTable");
84         pRtlLookupAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlLookupAtomInAtomTable");
85         pRtlPinAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlPinAtomInAtomTable");
86         pRtlQueryAtomInAtomTable = (void *)GetProcAddress(hntdll, "RtlQueryAtomInAtomTable");
87
88         pNtAddAtom = (void *)GetProcAddress(hntdll, "NtAddAtom");
89         pNtQueryInformationAtom = (void *)GetProcAddress(hntdll, "NtQueryInformationAtom");
90     }
91 }
92
93 static DWORD RtlAtomTestThread(LPVOID Table)
94 {
95     RTL_ATOM_TABLE AtomTable = *(PRTL_ATOM_TABLE)Table;
96     RTL_ATOM Atom;
97     NTSTATUS res;
98     ULONG RefCount = 0, PinCount = 0, Len = 0;
99     WCHAR Name[64];
100
101     res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &Atom);
102     ok(!res, "Unable to find atom from another thread, retval: %lx\n", res);
103
104     res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &Atom);
105     ok(!res, "Unable to lookup pinned atom in table, retval: %lx\n", res);
106
107     res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, Name, &Len);
108     ok(res == STATUS_BUFFER_TOO_SMALL, "We got wrong retval: %lx\n", res);
109
110     Len = 64;
111     res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, Name, &Len);
112     ok(!res, "Failed with longenough buffer, retval: %lx\n", res);
113     ok(RefCount == 1, "Refcount was not 1 but %lx\n", RefCount);
114     ok(PinCount == 1, "Pincount was not 1 but %lx\n", PinCount);
115     ok(!strcmpW(Name, testAtom2), "We found wrong atom!!\n");
116     ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len);
117
118     Len = 64;
119     res = pRtlQueryAtomInAtomTable(AtomTable, Atom, NULL, NULL, Name, &Len);
120     ok(!res, "RtlQueryAtomInAtomTable with optional args invalid failed, retval: %lx\n", res);
121     ok(!strcmpW(Name, testAtom2), "Found Wrong atom!\n");
122     ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len);
123
124     res = pRtlPinAtomInAtomTable(AtomTable, Atom);
125     ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
126
127     return 0;
128 }
129
130 static void test_NtAtom(void)
131 {
132     RTL_ATOM_TABLE AtomTable = NULL;
133     NTSTATUS res;
134     RTL_ATOM Atom1, Atom2, Atom3, testEAtom, testAtom;
135     HANDLE testThread;
136     ULONG RefCount = 0, PinCount = 0, Len = 0;
137     WCHAR Name[64];
138
139     /* If we pass a non-null string to create atom table, then it thinks that we
140      * have passed it an already allocated atom table */
141     res = pRtlCreateAtomTable(0, &AtomTable);
142     ok(!res, "RtlCreateAtomTable should succeed with an atom table size of 0\n");
143
144     if (!res)
145     {
146         res = pRtlDestroyAtomTable(AtomTable);
147         ok(!res, "We could create the atom table, but we couldn't destroy it! retval: %lx\n", res);
148     }
149
150     AtomTable = NULL;
151     res = pRtlCreateAtomTable(37, &AtomTable);
152     ok(!res, "We're unable to create an atom table with a valid table size retval: %lx\n", res);
153     if (!res)
154     {
155         res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1);
156         ok(!res, "We were unable to add a simple atom to the atom table, retval: %lx\n", res);
157
158         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1Cap, &testAtom);
159         ok(!res, "We were unable to find capital version of the atom, retval: %lx\n", res);
160         ok(Atom1 == testAtom, "Found wrong atom in table when querying capital atom\n");
161
162         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1Low, &testAtom);
163         ok(!res, "Unable to find lowercase version of the atom, retval: %lx\n", res);
164         ok(testAtom == Atom1, "Found wrong atom when querying lowercase atom\n");
165
166         res = pRtlAddAtomToAtomTable(AtomTable, EmptyAtom, &testEAtom);
167         ok(res == STATUS_OBJECT_NAME_INVALID, "Got wrong retval, retval: %lx\n", res);
168
169         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
170         ok(!res, "Failed to find totally legitimate atom, retval: %lx\n", res);
171         ok(testAtom == Atom1, "Found wrong atom!\n");
172
173         res = pRtlAddAtomToAtomTable(AtomTable, testAtom2, &Atom2);
174         ok(!res, "Unable to add other legitimate atom to table, retval: %lx\n", res);
175
176         res = pRtlPinAtomInAtomTable(AtomTable, Atom2);
177         ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
178
179         testThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RtlAtomTestThread, &AtomTable, 0, NULL);
180         WaitForSingleObject(testThread, INFINITE);
181
182         Len = 64;
183         res = pRtlQueryAtomInAtomTable(AtomTable, Atom2, &RefCount, &PinCount, Name, &Len);
184         ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
185         ok(RefCount == 1, "RefCount is not 1 but %lx\n", RefCount);
186         ok(PinCount == 1, "PinCount is not 1 but %lx\n", PinCount);
187         ok(!strcmpW(Name, testAtom2), "We found wrong atom\n");
188         ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len);
189
190         res = pRtlEmptyAtomTable(AtomTable, FALSE);
191         ok(!res, "Unable to empty atom table, retval %lx\n", res);
192
193         Len = 64;
194         res = pRtlQueryAtomInAtomTable(AtomTable, Atom2, &RefCount, &PinCount, Name, &Len);
195         ok(!res, "It seems RtlEmptyAtomTable deleted our pinned atom eaven though we asked it not to, retval: %lx\n", res);
196         ok(RefCount == 1, "RefCount is not 1 but %lx\n", RefCount);
197         ok(PinCount == 1, "PinCount is not 1 but %lx\n", PinCount);
198         ok(!strcmpW(Name, testAtom2), "We found wrong atom\n");
199         ok((strlenW(testAtom2) * sizeof(WCHAR)) == Len, "Returned wrong length %ld\n", Len);
200
201         Len = 8;
202         Name[0] = Name[1] = Name[2] = Name[3] = Name[4] = 0x55AA;
203         res = pRtlQueryAtomInAtomTable(AtomTable, Atom2, NULL, NULL, Name, &Len);
204         ok(!res, "query atom %lx\n", res);
205         ok(Len == 6, "wrong length %lu\n", Len);
206         ok(!memcmp(Name, testAtom2, Len), "wrong atom string\n");
207         ok(!Name[3], "wrong string termination\n");
208         ok(Name[4] == 0x55AA, "buffer overwrite\n");
209
210         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &testAtom);
211         ok(!res, "We can't find our pinned atom!! retval: %lx\n", res);
212         ok(testAtom == Atom2, "We found wrong atom!!!\n");
213
214         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
215         ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "We found the atom in our table eaven though we asked RtlEmptyAtomTable to remove it, retval: %lx\n", res);
216
217         res = pRtlAddAtomToAtomTable(AtomTable, testAtom3, &Atom3);
218         ok(!res, "Unable to add atom to table, retval: %lx\n", res);
219
220         res = pRtlEmptyAtomTable(AtomTable, TRUE);
221         ok(!res, "Unable to empty atom table, retval: %lx\n", res);
222
223         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom2, &testAtom);
224         ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "The pinned atom should be removed, retval: %lx\n", res);
225
226         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom3, &testAtom);
227         ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Non pinned atom should also be removed, retval: %lx\n", res);
228
229         res = pRtlDestroyAtomTable(AtomTable);
230         ok(!res, "Can't destroy atom table, retval: %lx\n", res);
231     }
232
233     AtomTable = NULL;
234     res = pRtlCreateAtomTable(37, &AtomTable);
235     ok(!res, "Unable to create atom table, retval: %lx\n", res);
236
237     if (!res)
238     {
239         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
240         ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Didn't get expected retval with querying an empty atom table, retval: %lx\n", res);
241
242         res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1);
243         ok(!res, "Unable to add atom to atom table, retval %lx\n", res);
244
245         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
246         ok(!res, "Can't find previously added atom in table, retval: %lx\n", res);
247         ok(testAtom == Atom1, "Found wrong atom! retval: %lx\n", res);
248
249         res = pRtlDeleteAtomFromAtomTable(AtomTable, Atom1);
250         ok(!res, "Unable to delete atom from table, retval: %lx\n", res);
251
252         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
253         ok(res == STATUS_OBJECT_NAME_NOT_FOUND, "Able to find previously deleted atom in table, retval: %lx\n", res);
254
255         res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1);
256         ok(!res, "Unable to add atom to atom table, retval: %lx\n", res);
257
258         Len = 0;
259         res = pRtlQueryAtomInAtomTable(AtomTable, Atom1, NULL, NULL, Name, &Len);
260         ok(res == STATUS_BUFFER_TOO_SMALL, "Got wrong retval, retval: %lx\n", res);
261         ok((strlenW(testAtom1) * sizeof(WCHAR)) == Len, "Got wrong length %lx\n", Len);
262
263         res = pRtlPinAtomInAtomTable(AtomTable, Atom1);
264         ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
265
266         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
267         ok(!res, "Unable to find atom in atom table, retval: %lx\n", res);
268         ok(testAtom == Atom1, "Wrong atom found\n");
269
270         res = pRtlDeleteAtomFromAtomTable(AtomTable, Atom1);
271         ok(res == STATUS_WAS_LOCKED, "Unable to delete atom from table, retval: %lx\n", res);
272
273         res = pRtlLookupAtomInAtomTable(AtomTable, testAtom1, &testAtom);
274         ok(!res, "Able to find deleted atom in table\n");
275
276         res = pRtlDestroyAtomTable(AtomTable);
277         ok(!res, "Unable to destroy atom table\n");
278     }
279 }
280
281 /* Test Adding integer atoms to atom table */
282 static void test_NtIntAtom(void)
283 {
284     NTSTATUS res;
285     RTL_ATOM_TABLE AtomTable;
286     RTL_ATOM testAtom;
287     ULONG RefCount = 0, PinCount = 0;
288     int i;
289     WCHAR Name[64];
290     ULONG Len;
291
292     AtomTable = NULL;
293     res = pRtlCreateAtomTable(37, &AtomTable);
294     ok(!res, "Unable to create atom table, %lx\n", res);
295
296     if (!res)
297     {
298         /* According to the kernel32 functions, integer atoms are only allowd from
299          * 0x0001 to 0xbfff and not 0xc000 to 0xffff, which is correct */
300         res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)0, &testAtom);
301         ok(res == STATUS_INVALID_PARAMETER, "Didn't get expected result from adding 0 int atom, retval: %lx\n", res);
302         for (i = 1; i <= 0xbfff; i++)
303         {
304             res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)i, &testAtom);
305             ok(!res, "Unable to add valid integer atom %i, retval: %lx\n", i, res);
306         }
307
308         for (i = 1; i <= 0xbfff; i++)
309         {
310             res = pRtlLookupAtomInAtomTable(AtomTable, (PWSTR)i, &testAtom);
311             ok(!res, "Unable to find int atom %i, retval: %lx\n", i, res);
312             if (!res)
313             {
314                 res = pRtlPinAtomInAtomTable(AtomTable, testAtom);
315                 ok(!res, "Unable to pin int atom %i, retval: %lx\n", i, res);
316             }
317         }
318
319         for (i = 0xc000; i <= 0xffff; i++)
320         {
321             res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)i, &testAtom);
322             ok(res, "Able to illeageal integer atom %i, retval: %lx\n", i, res);
323         }
324
325         res = pRtlDestroyAtomTable(AtomTable);
326         ok(!res, "Unable to destroy atom table, retval: %lx\n", res);
327     }
328
329     AtomTable = NULL;
330     res = pRtlCreateAtomTable(37, &AtomTable);
331     ok(!res, "Unable to create atom table, %lx\n", res);
332     if (!res)
333     {
334         res = pRtlLookupAtomInAtomTable(AtomTable, (PWSTR)123, &testAtom);
335         ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
336
337         res = pRtlAddAtomToAtomTable(AtomTable, testAtomInt, &testAtom);
338         ok(!res, "Unable to add int atom to table, retval: %lx\n", res);
339
340         res = pRtlAddAtomToAtomTable(AtomTable, testAtomIntInv, &testAtom);
341         ok(!res, "Unable to add int atom to table, retval: %lx\n", res);
342
343         res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)123, &testAtom);
344         ok(!res, "Unable to add int atom to table, retval: %lx\n", res);
345
346         res = pRtlAddAtomToAtomTable(AtomTable, (PWSTR)123, &testAtom);
347         ok(!res, "Unable to re-add int atom to table, retval: %lx\n", res);
348
349         Len = 64;
350         res = pRtlQueryAtomInAtomTable(AtomTable, testAtom, &RefCount, &PinCount, Name, &Len);
351         ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
352         ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount);
353         ok(RefCount == 1, "Expected refcount 1 but got %lx\n", RefCount);
354         ok(!strcmpW(testAtomOTT, Name), "Got wrong atom name\n");
355         ok((strlenW(testAtomOTT) * sizeof(WCHAR)) == Len, "Got wrong len %ld\n", Len);
356
357         res = pRtlPinAtomInAtomTable(AtomTable, testAtom);
358         ok(!res, "Unable to pin int atom, retval: %lx\n", res);
359
360         res = pRtlPinAtomInAtomTable(AtomTable, testAtom);
361         ok(!res, "Unable to pin int atom, retval: %lx\n", res);
362
363         res = pRtlQueryAtomInAtomTable(AtomTable, testAtom, &RefCount, &PinCount, NULL, NULL);
364         ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
365         ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount);
366         ok(RefCount == 1, "Expected refcount 1 but got %lx\n", RefCount);
367
368         res = pRtlDestroyAtomTable(AtomTable);
369         ok(!res, "Unable to destroy atom table, retval: %lx\n", res);
370     }
371 }
372
373 /* Tests to see how the pincount and refcount actually works */
374 static void test_NtRefPinAtom(void)
375 {
376     RTL_ATOM_TABLE AtomTable;
377     RTL_ATOM Atom;
378     ULONG PinCount = 0, RefCount = 0;
379     NTSTATUS res;
380
381     AtomTable = NULL;
382     res = pRtlCreateAtomTable(37, &AtomTable);
383     ok(!res, "Unable to create atom table, %lx\n", res);
384
385     if (!res)
386     {
387         res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom);
388         ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res);
389
390         res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom);
391         ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res);
392
393         res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom);
394         ok(!res, "Unable to add our atom to the atom table, retval: %lx\n", res);
395
396         res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, NULL, NULL);
397         ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
398         ok(PinCount == 0, "Expected pincount 0 but got %lx\n", PinCount);
399         ok(RefCount == 3, "Expected refcount 3 but got %lx\n", RefCount); 
400
401         res = pRtlPinAtomInAtomTable(AtomTable, Atom);
402         ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
403
404         res = pRtlPinAtomInAtomTable(AtomTable, Atom);
405         ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
406
407         res = pRtlPinAtomInAtomTable(AtomTable, Atom);
408         ok(!res, "Unable to pin atom in atom table, retval: %lx\n", res);
409
410         res = pRtlQueryAtomInAtomTable(AtomTable, Atom, &RefCount, &PinCount, NULL, NULL);
411         ok(!res, "Unable to query atom in atom table, retval: %lx\n", res);
412         ok(PinCount == 1, "Expected pincount 1 but got %lx\n", PinCount);
413         ok(RefCount == 3, "Expected refcount 3 but got %lx\n", RefCount);
414
415         res = pRtlDestroyAtomTable(AtomTable);
416         ok(!res, "Unable to destroy atom table, retval: %lx\n", res);
417     }
418 }
419
420 static void test_Global(void)
421 {
422     NTSTATUS    res;
423     RTL_ATOM    atom;
424     char        ptr[sizeof(ATOM_BASIC_INFORMATION) + 255 * sizeof(WCHAR)];
425     ATOM_BASIC_INFORMATION*     abi = (ATOM_BASIC_INFORMATION*)ptr;
426     ULONG       ptr_size = sizeof(ATOM_BASIC_INFORMATION) + 255 * sizeof(WCHAR);
427
428     res = pNtAddAtom(testAtom1, lstrlenW(testAtom1) * sizeof(WCHAR), &atom);
429     ok(!res, "Added atom (%lx)\n", res);
430
431     memset(abi->Name, 0x55, 255 * sizeof(WCHAR));
432     res = pNtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
433     ok(!res, "atom lookup\n");
434     ok(!lstrcmpW(abi->Name, testAtom1), "ok strings\n");
435     ok(abi->NameLength == lstrlenW(testAtom1) * sizeof(WCHAR), "wrong string length\n");
436     ok(abi->Name[lstrlenW(testAtom1)] == 0, "wrong string termination %x\n", abi->Name[lstrlenW(testAtom1)]);
437     ok(abi->Name[lstrlenW(testAtom1) + 1] == 0x5555, "buffer overwrite %x\n", abi->Name[lstrlenW(testAtom1) + 1]);
438
439     ptr_size = sizeof(ATOM_BASIC_INFORMATION);
440     res = pNtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
441     ok(res == STATUS_BUFFER_TOO_SMALL, "wrong return status (%lx)\n", res);
442     ok(abi->NameLength == lstrlenW(testAtom1) * sizeof(WCHAR), "ok string length\n");
443
444     memset(abi->Name, 0x55, lstrlenW(testAtom1) * sizeof(WCHAR));
445     ptr_size = sizeof(ATOM_BASIC_INFORMATION) + lstrlenW(testAtom1) * sizeof(WCHAR);
446     res = pNtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
447     ok(!res, "atom lookup %lx\n", res);
448     ok(!lstrcmpW(abi->Name, testAtom1), "strings don't match\n");
449     ok(abi->NameLength == lstrlenW(testAtom1) * sizeof(WCHAR), "wrong string length\n");
450     ok(abi->Name[lstrlenW(testAtom1)] == 0, "buffer overwrite %x\n", abi->Name[lstrlenW(testAtom1)]);
451     ok(abi->Name[lstrlenW(testAtom1) + 1] == 0x5555, "buffer overwrite %x\n", abi->Name[lstrlenW(testAtom1) + 1]);
452
453     ptr_size = sizeof(ATOM_BASIC_INFORMATION) + 4 * sizeof(WCHAR);
454     abi->Name[0] = abi->Name[1] = abi->Name[2] = abi->Name[3] = '\0';
455     res = pNtQueryInformationAtom( atom, AtomBasicInformation, (void*)ptr, ptr_size, NULL );
456     ok(!res, "couldn't find atom\n");
457     ok(abi->NameLength == 8, "wrong string length %u\n", abi->NameLength);
458     ok(!memcmp(abi->Name, testAtom1, 8), "strings don't match\n");
459 }
460
461 START_TEST(atom)
462 {
463     InitFunctionPtr();
464     if (pRtlCreateAtomTable)
465     {
466         test_NtAtom();
467         test_NtIntAtom();
468         test_NtRefPinAtom();
469         test_Global();
470     }
471 }