ReactOS 0.4.16-dev-112-g52265ae
RtlRangeList.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS kernel-mode tests
3 * LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
4 * PURPOSE: Test for Rtl Range Lists
5 * COPYRIGHT: Copyright 2020 Thomas Faber (thomas.faber@reactos.org)
6 */
7
8#include <kmt_test.h>
9#include <ndk/rtlfuncs.h>
10
11static UCHAR MyUserData1, MyUserData2;
12static UCHAR MyOwner1, MyOwner2;
13
14/* Helpers *******************************************************************/
15static
16NTSTATUS
17RtlAddRangeWrapper(
18 _Inout_ PRTL_RANGE_LIST RangeList,
19 _In_ const RTL_RANGE *Range,
20 _In_ ULONG Flags)
21{
22 return RtlAddRange(RangeList,
23 Range->Start,
24 Range->End,
25 Range->Attributes,
26 Flags,
27 Range->UserData,
28 Range->Owner);
29}
30
31static
32void
33ExpectRange(
34 _In_ PCSTR File,
35 _In_ INT Line,
36 _In_ ULONG Index,
37 _In_ const RTL_RANGE *ActualRange,
38 _In_ const RTL_RANGE *ExpectedRange)
39{
40 CHAR FileAndLine[128];
41 RtlStringCbPrintfA(FileAndLine, sizeof(FileAndLine), "%s:%d", File, Line);
42
43 KmtOk(ActualRange->Start == ExpectedRange->Start, FileAndLine,
44 "[%lu] Start = 0x%I64x, expected 0x%I64x\n", Index, ActualRange->Start, ExpectedRange->Start);
45 KmtOk(ActualRange->End == ExpectedRange->End, FileAndLine,
46 "[%lu] End = 0x%I64x, expected 0x%I64x\n", Index, ActualRange->End, ExpectedRange->End);
47 KmtOk(ActualRange->UserData == ExpectedRange->UserData, FileAndLine,
48 "[%lu] UserData = %p, expected %p\n", Index, ActualRange->UserData, ExpectedRange->UserData);
49 KmtOk(ActualRange->Owner == ExpectedRange->Owner, FileAndLine,
50 "[%lu] Owner = %p, expected %p\n", Index, ActualRange->Owner, ExpectedRange->Owner);
51 KmtOk(ActualRange->Attributes == ExpectedRange->Attributes, FileAndLine,
52 "[%lu] Attributes = 0x%x, expected 0x%x\n", Index, ActualRange->Attributes, ExpectedRange->Attributes);
53 KmtOk(ActualRange->Flags == ExpectedRange->Flags, FileAndLine,
54 "[%lu] Flags = 0x%x, expected 0x%x\n", Index, ActualRange->Flags, ExpectedRange->Flags);
55}
56
57static
58void
59ExpectRangeEntryList(
60 _In_ PCSTR File,
61 _In_ INT Line,
62 _In_ RTL_RANGE_LIST *RangeList,
63 _In_ ULONG NumRanges,
64 _In_reads_(NumRanges) const RTL_RANGE *Ranges)
65{
66 NTSTATUS Status;
67 ULONG i;
68 RTL_RANGE_LIST_ITERATOR Iterator;
69 PRTL_RANGE Range;
70 CHAR FileAndLine[128];
71 RtlStringCbPrintfA(FileAndLine, sizeof(FileAndLine), "%s:%d", File, Line);
72
73 RtlFillMemory(&Iterator, sizeof(Iterator), 0x55);
74 Range = KmtInvalidPointer;
75 Status = RtlGetFirstRange(RangeList, &Iterator, &Range);
76#ifdef _WIN64
77 /* Padding at the end is uninitialized */
78 C_ASSERT(sizeof(Iterator) == RTL_SIZEOF_THROUGH_FIELD(RTL_RANGE_LIST_ITERATOR, Stamp) + sizeof(ULONG));
79 KmtOk((&Iterator.Stamp)[1] == 0x55555555, FileAndLine,
80 "Padding is 0x%lx\n", (&Iterator.Stamp)[1]);
81#endif
82
83 for (i = 0; i < NumRanges; i++)
84 {
85 if (!KmtSkip(NT_SUCCESS(Status), FileAndLine, "Range does not have %lu element(s)\n", i + 1))
86 {
87 ExpectRange(File, Line, i, Range, &Ranges[i]);
88
89 /* Validate iterator */
90 KmtOk(Iterator.RangeListHead == &RangeList->ListHead, FileAndLine,
91 "[%lu] Iterator.RangeListHead = %p, expected %p\n", i, Iterator.RangeListHead, &RangeList->ListHead);
92 KmtOk(Iterator.MergedHead == NULL, FileAndLine,
93 "[%lu] Iterator.MergedHead = %p\n", i, Iterator.MergedHead);
94 KmtOk(Iterator.Current == Range, FileAndLine,
95 "[%lu] Iterator.Current = %p, expected %p\n", i, Iterator.Current, Range);
96 KmtOk(Iterator.Stamp == RangeList->Stamp, FileAndLine,
97 "[%lu] Iterator.Stamp = %lu, expected %lu\n", i, Iterator.Stamp, RangeList->Stamp);
98 }
99
100 Range = KmtInvalidPointer;
101 Status = RtlGetNextRange(&Iterator, &Range, TRUE);
102 }
103
104 /* Final iteration status */
105 KmtOk(Status == STATUS_NO_MORE_ENTRIES, FileAndLine,
106 "Status = 0x%lx after enumeration\n", Status);
107 KmtOk(Range == NULL, FileAndLine,
108 "[%lu] Range = %p\n", i, Range);
109 KmtOk(Iterator.RangeListHead == &RangeList->ListHead, FileAndLine,
110 "[%lu] Iterator.RangeListHead = %p, expected %p\n", i, Iterator.RangeListHead, &RangeList->ListHead);
111 KmtOk(Iterator.MergedHead == NULL, FileAndLine,
112 "[%lu] Iterator.MergedHead = %p\n", i, Iterator.MergedHead);
113 KmtOk(Iterator.Current == NULL, FileAndLine,
114 "[%lu] Iterator.Current = %p\n", i, Iterator.Current);
115 KmtOk(Iterator.Stamp == RangeList->Stamp, FileAndLine,
116 "[%lu] Iterator.Stamp = %lu, expected %lu\n", i, Iterator.Stamp, RangeList->Stamp);
117
118 /* Try one more iteration */
119 Range = KmtInvalidPointer;
120 Status = RtlGetNextRange(&Iterator, &Range, TRUE);
121 KmtOk(Status == STATUS_NO_MORE_ENTRIES, FileAndLine,
122 "Status = 0x%lx after enumeration\n", Status);
123 KmtOk(Range == NULL, FileAndLine,
124 "[%lu] Range = %p\n", i, Range);
125 KmtOk(Iterator.RangeListHead == &RangeList->ListHead, FileAndLine,
126 "[%lu] Iterator.RangeListHead = %p, expected %p\n", i, Iterator.RangeListHead, &RangeList->ListHead);
127 KmtOk(Iterator.MergedHead == NULL, FileAndLine,
128 "[%lu] Iterator.MergedHead = %p\n", i, Iterator.MergedHead);
129 KmtOk(Iterator.Current == NULL, FileAndLine,
130 "[%lu] Iterator.Current = %p\n", i, Iterator.Current);
131 KmtOk(Iterator.Stamp == RangeList->Stamp, FileAndLine,
132 "[%lu] Iterator.Stamp = %lu, expected %lu\n", i, Iterator.Stamp, RangeList->Stamp);
133}
134
135#define expect_range_entries(RangeList, NumRanges, Ranges) \
136 ExpectRangeEntryList(__FILE__, __LINE__, RangeList, NumRanges, Ranges)
137
138/* Test functions ************************************************************/
139static
140void
141TestStartGreaterThanEnd(
142 _Inout_ PRTL_RANGE_LIST RangeList,
143 _Inout_ PRTL_RANGE Ranges)
144{
145 NTSTATUS Status;
146 ULONG StartStamp = RangeList->Stamp;
147
148 Ranges[1].Start = 0x300;
149 Ranges[1].End = 0x2ff;
150 Ranges[1].Attributes = 2;
151 Ranges[1].Flags = 0;
152 Ranges[1].UserData = &MyUserData2;
153 Ranges[1].Owner = &MyOwner2;
154
155 /* Start > End bails out early with invalid parameter */
156 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], 0);
157 ok_eq_hex(Status, STATUS_INVALID_PARAMETER);
158
159 /* List should be unchanged */
160 ok_eq_ulong(RangeList->Flags, 0UL);
161 ok_eq_ulong(RangeList->Count, 1UL);
162 ok_eq_ulong(RangeList->Stamp, StartStamp);
163 expect_range_entries(RangeList, 1, &Ranges[0]);
164}
165
166static
167void
168TestStartEqualsEnd(
169 _Inout_ PRTL_RANGE_LIST RangeList,
170 _Inout_ PRTL_RANGE Ranges)
171{
172 NTSTATUS Status;
173 ULONG StartStamp = RangeList->Stamp;
174
175 Ranges[1].Start = 0x300;
176 Ranges[1].End = 0x300;
177 Ranges[1].Attributes = 0xff;
178 Ranges[1].Flags = 0;
179 Ranges[1].UserData = &MyUserData2;
180 Ranges[1].Owner = &MyOwner2;
181
182 /* Start == End is valid */
183 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], 0);
184 ok_eq_hex(Status, STATUS_SUCCESS);
185
186 /* List now has two entries */
187 ok_eq_ulong(RangeList->Flags, 0UL);
188 ok_eq_ulong(RangeList->Count, 2UL);
189 ok_eq_ulong(RangeList->Stamp, StartStamp + 1);
190 expect_range_entries(RangeList, 2, &Ranges[0]);
191
192 /* Delete our new entry -- List goes back to one entry */
193 Status = RtlDeleteRange(RangeList, Ranges[1].Start, Ranges[1].End, Ranges[1].Owner);
194 ok_eq_hex(Status, STATUS_SUCCESS);
195 ok_eq_ulong(RangeList->Flags, 0UL);
196 ok_eq_ulong(RangeList->Count, 1UL);
197 ok_eq_ulong(RangeList->Stamp, StartStamp + 2);
198 expect_range_entries(RangeList, 1, &Ranges[0]);
199}
200
201static
202void
203TestSharedFlag(
204 _Inout_ PRTL_RANGE_LIST RangeList,
205 _Inout_ PRTL_RANGE Ranges)
206{
207 NTSTATUS Status;
208 ULONG StartStamp = RangeList->Stamp;
209
210 Ranges[1].Start = 0x300;
211 Ranges[1].End = 0x400;
212 Ranges[1].Attributes = 2;
213 Ranges[1].Flags = RTL_RANGE_SHARED;
214 Ranges[1].UserData = &MyUserData2;
215 Ranges[1].Owner = &MyOwner2;
216
217 /* Pass in the shared flag */
218 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], RTL_RANGE_LIST_ADD_SHARED);
219 ok_eq_hex(Status, STATUS_SUCCESS);
220
221 /* List now has two entries */
222 ok_eq_ulong(RangeList->Flags, 0UL);
223 ok_eq_ulong(RangeList->Count, 2UL);
224 ok_eq_ulong(RangeList->Stamp, StartStamp + 1);
225 expect_range_entries(RangeList, 2, &Ranges[0]);
226
227 /* Delete our new entry -- List goes back to one entry */
228 Status = RtlDeleteRange(RangeList, Ranges[1].Start, Ranges[1].End, Ranges[1].Owner);
229 ok_eq_hex(Status, STATUS_SUCCESS);
230 ok_eq_ulong(RangeList->Flags, 0UL);
231 ok_eq_ulong(RangeList->Count, 1UL);
232 ok_eq_ulong(RangeList->Stamp, StartStamp + 2);
233 expect_range_entries(RangeList, 1, &Ranges[0]);
234}
235
236static
237void
238TestIsAvailable(
239 _Inout_ PRTL_RANGE_LIST RangeList,
240 _Inout_ PRTL_RANGE Ranges)
241{
242 NTSTATUS Status;
243 BOOLEAN Available;
244 ULONG StartStamp = RangeList->Stamp;
245
246#define is_range_available(RangeList, Start, End, pAvail) \
247 RtlIsRangeAvailable(RangeList, \
248 Start, \
249 End, \
250 0, \
251 0, \
252 NULL, \
253 NULL, \
254 pAvail)
255
256 /* Single item range before Start */
257 Status = is_range_available(RangeList,
258 Ranges[0].Start - 1,
259 Ranges[0].Start - 1,
260 &Available);
261 ok_eq_hex(Status, STATUS_SUCCESS);
262 ok_eq_bool(Available, TRUE);
263
264 /* Single item range at Start */
265 Status = is_range_available(RangeList,
266 Ranges[0].Start,
267 Ranges[0].Start,
268 &Available);
269 ok_eq_hex(Status, STATUS_SUCCESS);
270 ok_eq_bool(Available, FALSE);
271
272 /* Single item range at End */
273 Status = is_range_available(RangeList,
274 Ranges[0].End,
275 Ranges[0].End,
276 &Available);
277 ok_eq_hex(Status, STATUS_SUCCESS);
278 ok_eq_bool(Available, FALSE);
279
280 /* Single item range after End */
281 Status = is_range_available(RangeList,
282 Ranges[0].End + 1,
283 Ranges[0].End + 1,
284 &Available);
285 ok_eq_hex(Status, STATUS_SUCCESS);
286 ok_eq_bool(Available, TRUE);
287
288 /* Range ending before Start */
289 Status = is_range_available(RangeList,
290 0x0,
291 Ranges[0].Start - 1,
292 &Available);
293 ok_eq_hex(Status, STATUS_SUCCESS);
294 ok_eq_bool(Available, TRUE);
295
296 /* Range ending at Start */
297 Status = is_range_available(RangeList,
298 0x0,
299 Ranges[0].Start,
300 &Available);
301 ok_eq_hex(Status, STATUS_SUCCESS);
302 ok_eq_bool(Available, FALSE);
303
304 /* Range ending in the middle */
305 Status = is_range_available(RangeList,
306 0x0,
307 (Ranges[0].Start + Ranges[0].End) / 2,
308 &Available);
309 ok_eq_hex(Status, STATUS_SUCCESS);
310 ok_eq_bool(Available, FALSE);
311
312 /* Range going all the way through */
313 Status = is_range_available(RangeList,
314 0x0,
315 Ranges[0].End + 0x100,
316 &Available);
317 ok_eq_hex(Status, STATUS_SUCCESS);
318 ok_eq_bool(Available, FALSE);
319
320 /* Range starting in the middle */
321 Status = is_range_available(RangeList,
322 (Ranges[0].Start + Ranges[0].End) / 2,
323 Ranges[0].End + 0x100,
324 &Available);
325 ok_eq_hex(Status, STATUS_SUCCESS);
326 ok_eq_bool(Available, FALSE);
327
328 /* Range starting at End */
329 Status = is_range_available(RangeList,
330 Ranges[0].End,
331 Ranges[0].End + 0x100,
332 &Available);
333 ok_eq_hex(Status, STATUS_SUCCESS);
334 ok_eq_bool(Available, FALSE);
335
336 /* Range starting after End */
337 Status = is_range_available(RangeList,
338 Ranges[0].End + 1,
339 Ranges[0].End + 0x100,
340 &Available);
341 ok_eq_hex(Status, STATUS_SUCCESS);
342 ok_eq_bool(Available, TRUE);
343
344 /* Start > End, at start */
345 Status = is_range_available(RangeList,
346 Ranges[0].Start,
347 Ranges[0].Start - 1,
348 &Available);
349 ok_eq_hex(Status, STATUS_SUCCESS);
350 ok_eq_bool(Available, TRUE);
351
352 /* Start > End, at start */
353 Status = is_range_available(RangeList,
354 Ranges[0].Start + 1,
355 Ranges[0].Start,
356 &Available);
357 ok_eq_hex(Status, STATUS_SUCCESS);
358 ok_eq_bool(Available, FALSE);
359
360 /* Start > End, at end */
361 Status = is_range_available(RangeList,
362 Ranges[0].End + 1,
363 Ranges[0].End,
364 &Available);
365 ok_eq_hex(Status, STATUS_SUCCESS);
366 ok_eq_bool(Available, TRUE);
367
368 /* Start > End, at end */
369 Status = is_range_available(RangeList,
370 Ranges[0].End,
371 Ranges[0].End - 1,
372 &Available);
373 ok_eq_hex(Status, STATUS_SUCCESS);
374 ok_eq_bool(Available, FALSE);
375
376 /* Start > End, through the range */
377 Status = is_range_available(RangeList,
378 Ranges[0].End + 1,
379 Ranges[0].Start - 1,
380 &Available);
381 ok_eq_hex(Status, STATUS_SUCCESS);
382 ok_eq_bool(Available, TRUE);
383
384 /* AttributesAvailableMask will make our range available */
385 Status = RtlIsRangeAvailable(RangeList,
386 0x0,
387 Ranges[0].End + 0x100,
388 0,
389 Ranges[0].Attributes,
390 NULL,
391 NULL,
392 &Available);
393 ok_eq_hex(Status, STATUS_SUCCESS);
394 ok_eq_bool(Available, TRUE);
395
396 /* AttributesAvailableMask with additional bits */
397 Status = RtlIsRangeAvailable(RangeList,
398 0x0,
399 Ranges[0].End + 0x100,
400 0,
401 0xFF,
402 NULL,
403 NULL,
404 &Available);
405 ok_eq_hex(Status, STATUS_SUCCESS);
406 ok_eq_bool(Available, TRUE);
407
408 ok_eq_ulong(RangeList->Stamp, StartStamp);
409}
410
411/* Entry point ***************************************************************/
412START_TEST(RtlRangeList)
413{
414 NTSTATUS Status;
415 RTL_RANGE_LIST RangeList;
416 RTL_RANGE Ranges[5];
417 ULONG Stamp;
418
419 RtlFillMemory(&RangeList, sizeof(RangeList), 0x55);
420 RtlInitializeRangeList(&RangeList);
421 ok(IsListEmpty(&RangeList.ListHead),
422 "RangeList.ListHead %p %p %p, expected empty\n",
423 &RangeList.ListHead, RangeList.ListHead.Flink, RangeList.ListHead.Blink);
424 ok_eq_ulong(RangeList.Flags, 0UL);
425 ok_eq_ulong(RangeList.Count, 0UL);
426 ok_eq_ulong(RangeList.Stamp, 0UL);
427#ifdef _WIN64
428 /* Padding at the end is uninitialized */
429 C_ASSERT(sizeof(RangeList) == RTL_SIZEOF_THROUGH_FIELD(RTL_RANGE_LIST, Stamp) + sizeof(ULONG));
430 ok_eq_ulong((&RangeList.Stamp)[1], 0x55555555UL);
431#endif
432
433 /* Add a simple range */
434 Ranges[0].Start = 0x100;
435 Ranges[0].End = 0x200;
436 Ranges[0].Attributes = 1;
437 Ranges[0].Flags = 0;
438 Ranges[0].UserData = &MyUserData1;
439 Ranges[0].Owner = &MyOwner1;
440 Status = RtlAddRangeWrapper(&RangeList, &Ranges[0], 0);
441 ok_eq_hex(Status, STATUS_SUCCESS);
442 ok_eq_ulong(RangeList.Flags, 0UL);
443 ok_eq_ulong(RangeList.Count, 1UL);
444 ok_eq_ulong(RangeList.Stamp, 1UL);
445 expect_range_entries(&RangeList, 1, &Ranges[0]);
446
447 /*
448 * Individual tests.
449 * These should always leave the list with our single start entry.
450 * Stamp may change between tests.
451 */
452 TestStartGreaterThanEnd(&RangeList, Ranges);
453 TestStartEqualsEnd(&RangeList, Ranges);
454 TestSharedFlag(&RangeList, Ranges);
455 TestIsAvailable(&RangeList, Ranges);
456
457 Stamp = RangeList.Stamp;
458
459 /* Free it and check the result */
460 RtlFreeRangeList(&RangeList);
461 ok_eq_ulong(RangeList.Flags, 0UL);
462 ok_eq_ulong(RangeList.Count, 0UL);
463 ok_eq_ulong(RangeList.Stamp, Stamp);
464 expect_range_entries(&RangeList, 0, NULL);
465}
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
RtlAddRangeWrapper
static NTSTATUS RtlAddRangeWrapper(_Inout_ PRTL_RANGE_LIST RangeList, _In_ const RTL_RANGE *Range, _In_ ULONG Flags)
Definition: RtlRangeList.c:17
ExpectRangeEntryList
static void ExpectRangeEntryList(_In_ PCSTR File, _In_ INT Line, _In_ RTL_RANGE_LIST *RangeList, _In_ ULONG NumRanges, _In_reads_(NumRanges) const RTL_RANGE *Ranges)
Definition: RtlRangeList.c:59
MyUserData1
static UCHAR MyUserData1
Definition: RtlRangeList.c:11
MyOwner2
static UCHAR MyOwner2
Definition: RtlRangeList.c:12
ExpectRange
static void ExpectRange(_In_ PCSTR File, _In_ INT Line, _In_ ULONG Index, _In_ const RTL_RANGE *ActualRange, _In_ const RTL_RANGE *ExpectedRange)
Definition: RtlRangeList.c:33
TestStartEqualsEnd
static void TestStartEqualsEnd(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:168
MyOwner1
static UCHAR MyOwner1
Definition: RtlRangeList.c:12
expect_range_entries
#define expect_range_entries(RangeList, NumRanges, Ranges)
Definition: RtlRangeList.c:135
TestStartGreaterThanEnd
static void TestStartGreaterThanEnd(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:141
is_range_available
#define is_range_available(RangeList, Start, End, pAvail)
MyUserData2
static UCHAR MyUserData2
Definition: RtlRangeList.c:11
TestIsAvailable
static void TestIsAvailable(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:238
TestSharedFlag
static void TestSharedFlag(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:203
ok_eq_hex
#define ok_eq_hex(value, expected)
Definition: apitest.h:77
ok_eq_ulong
#define ok_eq_ulong(value, expected)
Definition: apitest.h:63
ok_eq_bool
#define ok_eq_bool(value, expected)
Definition: apitest.h:80
ok
#define ok(value,...)
Definition: atltest.h:57
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
File
Definition: File.h:16
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
IsListEmpty
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
Start
return pTarget Start()
Status
Status
Definition: gdiplustypes.h:25
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
RtlFillMemory
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:599
C_ASSERT
#define C_ASSERT(e)
Definition: intsafe.h:73
kmt_test.h
KmtOk
BOOLEAN BOOLEAN KmtOk(INT Condition, PCSTR FileAndLine, PCSTR Format,...) KMT_FORMAT(ms_printf
KmtSkip
BOOLEAN BOOLEAN VOID VOID BOOLEAN BOOLEAN KmtSkip(INT Condition, PCSTR FileAndLine, PCSTR Format,...) KMT_FORMAT(ms_printf
KmtInvalidPointer
#define KmtInvalidPointer
Definition: kmt_test.h:280
_Inout_
#define _Inout_
Definition: ms_sal.h:378
_In_
#define _In_
Definition: ms_sal.h:308
_In_reads_
#define _In_reads_(size)
Definition: ms_sal.h:319
RtlIsRangeAvailable
NTSYSAPI NTSTATUS NTAPI RtlIsRangeAvailable(_In_ PRTL_RANGE_LIST RangeList, _In_ ULONGLONG Start, _In_ ULONGLONG End, _In_ ULONG Flags, _In_ UCHAR AttributeAvailableMask, _In_opt_ PVOID Context, _In_opt_ PRTL_CONFLICT_RANGE_CALLBACK Callback, _Out_ PBOOLEAN Available)
Owner
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1609
RtlDeleteRange
NTSYSAPI NTSTATUS NTAPI RtlDeleteRange(_Inout_ PRTL_RANGE_LIST RangeList, _In_ ULONGLONG Start, _In_ ULONGLONG End, _In_ PVOID Owner)
RtlAddRange
NTSYSAPI NTSTATUS NTAPI RtlAddRange(_Inout_ PRTL_RANGE_LIST RangeList, _In_ ULONGLONG Start, _In_ ULONGLONG End, _In_ UCHAR Attributes, _In_ ULONG Flags, _In_opt_ PVOID UserData, _In_opt_ PVOID Owner)
RtlInitializeRangeList
NTSYSAPI VOID NTAPI RtlInitializeRangeList(_Out_ PRTL_RANGE_LIST RangeList)
RtlGetNextRange
NTSYSAPI NTSTATUS NTAPI RtlGetNextRange(_Inout_ PRTL_RANGE_LIST_ITERATOR Iterator, _Outptr_ PRTL_RANGE *Range, _In_ BOOLEAN MoveForwards)
RtlGetFirstRange
NTSYSAPI NTSTATUS NTAPI RtlGetFirstRange(_In_ PRTL_RANGE_LIST RangeList, _Out_ PRTL_RANGE_LIST_ITERATOR Iterator, _Outptr_ PRTL_RANGE *Range)
RtlFreeRangeList
NTSYSAPI VOID NTAPI RtlFreeRangeList(_In_ PRTL_RANGE_LIST RangeList)
RTL_RANGE_LIST_ADD_SHARED
#define RTL_RANGE_LIST_ADD_SHARED
Definition: rtltypes.h:82
RTL_RANGE_SHARED
#define RTL_RANGE_SHARED
Definition: rtltypes.h:84
RTL_SIZEOF_THROUGH_FIELD
#define RTL_SIZEOF_THROUGH_FIELD(type, field)
Definition: ntbasedef.h:672
STATUS_NO_MORE_ENTRIES
#define STATUS_NO_MORE_ENTRIES
Definition: ntstatus.h:205
RtlStringCbPrintfA
NTSTRSAFEVAPI RtlStringCbPrintfA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1148
Range
struct tagRange Range
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
Line
Definition: ncftp.h:79
_LIST_ENTRY::Blink
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_RANGE_LIST_ITERATOR
Definition: rtltypes.h:1478
_RTL_RANGE_LIST
Definition: rtltypes.h:1460
_RTL_RANGE_LIST::Stamp
ULONG Stamp
Definition: rtltypes.h:1464
_RTL_RANGE_LIST::ListHead
LIST_ENTRY ListHead
Definition: rtltypes.h:1461
_RTL_RANGE_LIST::Count
ULONG Count
Definition: rtltypes.h:1463
_RTL_RANGE_LIST::Flags
ULONG Flags
Definition: rtltypes.h:1462
_RTL_RANGE
Definition: rtltypes.h:1468
_RTL_RANGE::End
ULONGLONG End
Definition: rtltypes.h:1470
_RTL_RANGE::Start
ULONGLONG Start
Definition: rtltypes.h:1469
_RTL_RANGE::Attributes
UCHAR Attributes
Definition: rtltypes.h:1473
_RTL_RANGE::UserData
PVOID UserData
Definition: rtltypes.h:1471
_RTL_RANGE::Owner
PVOID Owner
Definition: rtltypes.h:1472
_RTL_RANGE::Flags
UCHAR Flags
Definition: rtltypes.h:1474
tagRange
Definition: range.c:39
UL
#define UL
Definition: tui.h:165
INT
int32_t INT
Definition: typedefs.h:58
PCSTR
const char * PCSTR
Definition: typedefs.h:52
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
Iterator
_In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR Iterator
Definition: wdfchildlist.h:656
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:182
Attributes
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
Definition: wdfcommonbuffer.h:97
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181
CHAR
char CHAR
Definition: xmlstorage.h:175