[NTDLL_APITEST]

- Add a test for RtlImageRvaToVa
CORE-10523

svn path=/trunk/; revision=69895

diff --git a/rostests/apitests/ntdll/CMakeLists.txt b/rostests/apitests/ntdll/CMakeLists.txt
index 7345855..2909fe4 100644 (file)
--- a/rostests/apitests/ntdll/CMakeLists.txt
+++ b/rostests/apitests/ntdll/CMakeLists.txt
@@ -31,6 +31,7 @@ list(APPEND SOURCE
     RtlGetFullPathName_UstrEx.c
     RtlGetLengthWithoutTrailingPathSeperators.c
     RtlGetLongestNtPathLength.c
+    RtlImageRvaToVa.c
     RtlInitializeBitMap.c
     RtlMemoryStream.c
     RtlReAllocateHeap.c

diff --git a/rostests/apitests/ntdll/RtlImageRvaToVa.c b/rostests/apitests/ntdll/RtlImageRvaToVa.c
new file mode 100644 (file)
index 0000000..2671f86
--- /dev/null
+++ b/rostests/apitests/ntdll/RtlImageRvaToVa.c
@@ -0,0 +1,235 @@
+/*
+ * PROJECT:         ReactOS api tests
+ * LICENSE:         LGPLv2.1+ - See COPYING.LIB in the top level directory
+ * PURPOSE:         Test for RtlImageRvaToVa
+ * PROGRAMMERS:     Thomas Faber <thomas.faber@reactos.org>
+ */
+
+#include <apitest.h>
+#include <ndk/mmfuncs.h>
+#include <ndk/rtlfuncs.h>
+
+static
+PVOID
+AllocateGuarded(
+    _In_ SIZE_T SizeRequested)
+{
+    NTSTATUS Status;
+    SIZE_T Size = PAGE_ROUND_UP(SizeRequested + PAGE_SIZE);
+    PVOID VirtualMemory = NULL;
+    PCHAR StartOfBuffer;
+
+    Status = NtAllocateVirtualMemory(NtCurrentProcess(), &VirtualMemory, 0, &Size, MEM_RESERVE, PAGE_NOACCESS);
+
+    if (!NT_SUCCESS(Status))
+        return NULL;
+
+    Size -= PAGE_SIZE;
+    if (Size)
+    {
+        Status = NtAllocateVirtualMemory(NtCurrentProcess(), &VirtualMemory, 0, &Size, MEM_COMMIT, PAGE_READWRITE);
+        if (!NT_SUCCESS(Status))
+        {
+            Size = 0;
+            Status = NtFreeVirtualMemory(NtCurrentProcess(), &VirtualMemory, &Size, MEM_RELEASE);
+            ok(Status == STATUS_SUCCESS, "Status = %lx\n", Status);
+            return NULL;
+        }
+    }
+
+    StartOfBuffer = VirtualMemory;
+    StartOfBuffer += Size - SizeRequested;
+
+    return StartOfBuffer;
+}
+
+static
+VOID
+FreeGuarded(
+    _In_ PVOID Pointer)
+{
+    NTSTATUS Status;
+    PVOID VirtualMemory = (PVOID)PAGE_ROUND_DOWN((SIZE_T)Pointer);
+    SIZE_T Size = 0;
+
+    Status = NtFreeVirtualMemory(NtCurrentProcess(), &VirtualMemory, &Size, MEM_RELEASE);
+    ok(Status == STATUS_SUCCESS, "Status = %lx\n", Status);
+}
+
+START_TEST(RtlImageRvaToVa)
+{
+    PIMAGE_NT_HEADERS NtHeader;
+    PIMAGE_SECTION_HEADER Section;
+    ULONG NumberOfSections;
+    ULONG ImageSize;
+    PUCHAR BaseAddress;
+    PVOID Va;
+    PIMAGE_SECTION_HEADER OutSection;
+    IMAGE_SECTION_HEADER DummySection;
+    struct
+    {
+        ULONG Rva;
+        ULONG VaOffset;
+        ULONG SectionIndex;
+    } Tests[] =
+    {
+        {      0,      0, 0 },
+        {  0xfff,      0, 0 },
+        { 0x1000, 0x3000, 0 },
+        { 0x1001, 0x3001, 0 },
+        { 0x1fff, 0x3fff, 0 },
+        { 0x2000,      0, 0 },
+        { 0x2fff,      0, 0 },
+        { 0x3000, 0x4000, 3 },
+        { 0x3fff, 0x4fff, 3 },
+        { 0x4000, 0x5000, 3 },
+        { 0x4fff, 0x5fff, 3 },
+        { 0x5000,      0, 0 },
+        { 0x5fff,      0, 0 },
+        { 0x6000,      0, 0 },
+        { 0x6fff,      0, 0 },
+        { 0x7000, 0x7000, 5 },
+        { 0x7fff, 0x7fff, 5 },
+        { 0x8000, 0x9000, 7 },
+        { 0x8fff, 0x9fff, 7 },
+        { 0x9000, 0x8000, 6 },
+        { 0x9fff, 0x8fff, 6 },
+    };
+    ULONG i;
+
+    NumberOfSections = 8;
+    ImageSize = FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader.DataDirectory) +
+                NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
+    NtHeader = AllocateGuarded(ImageSize);
+    if (!NtHeader)
+    {
+        skip("Could not allocate %lu bytes\n", ImageSize);
+        return;
+    }
+
+    RtlFillMemory(NtHeader, ImageSize, 0xDD);
+    NtHeader->FileHeader.NumberOfSections = NumberOfSections;
+    NtHeader->FileHeader.SizeOfOptionalHeader = FIELD_OFFSET(IMAGE_OPTIONAL_HEADER, DataDirectory);
+    Section = (PIMAGE_SECTION_HEADER)((PUCHAR)&NtHeader->OptionalHeader +
+                                      NtHeader->FileHeader.SizeOfOptionalHeader);
+    Section[0].VirtualAddress = 0x1000;
+    Section[0].Misc.VirtualSize = 0x1000;
+    Section[0].SizeOfRawData = 0x1000;
+    Section[0].PointerToRawData = 0x3000;
+    Section[1].VirtualAddress = 0x2000;
+    Section[1].Misc.VirtualSize = 0;
+    Section[1].SizeOfRawData = 0;
+    Section[1].PointerToRawData = 0x4000;
+    Section[2].VirtualAddress = 0x2000;
+    Section[2].Misc.VirtualSize = 0x1000;
+    Section[2].SizeOfRawData = 0;
+    Section[2].PointerToRawData = 0x4000;
+    Section[3].VirtualAddress = 0x3000;
+    Section[3].Misc.VirtualSize = 0x1000;
+    Section[3].SizeOfRawData = 0x2000;
+    Section[3].PointerToRawData = 0x4000;
+    Section[4].VirtualAddress = 0x4000;
+    Section[4].Misc.VirtualSize = 0x2000;
+    Section[4].SizeOfRawData = 0x1000;
+    Section[4].PointerToRawData = 0x6000;
+    Section[5].VirtualAddress = 0x7000;
+    Section[5].Misc.VirtualSize = 0x1000;
+    Section[5].SizeOfRawData = 0x1000;
+    Section[5].PointerToRawData = 0x7000;
+    Section[6].VirtualAddress = 0x9000;
+    Section[6].Misc.VirtualSize = 0x1000;
+    Section[6].SizeOfRawData = 0x1000;
+    Section[6].PointerToRawData = 0x8000;
+    Section[7].VirtualAddress = 0x8000;
+    Section[7].Misc.VirtualSize = 0x1000;
+    Section[7].SizeOfRawData = 0x1000;
+    Section[7].PointerToRawData = 0x9000;
+    DummySection.VirtualAddress = 0xf000;
+    DummySection.Misc.VirtualSize = 0xf000;
+    DummySection.SizeOfRawData = 0xf000;
+    DummySection.PointerToRawData = 0xf000;
+
+    BaseAddress = (PUCHAR)0x2000000;
+
+    StartSeh()
+        RtlImageRvaToVa(NULL, NULL, 0, NULL);
+    EndSeh(STATUS_ACCESS_VIOLATION);
+
+    Va = RtlImageRvaToVa(NtHeader, NULL, 0, NULL);
+    ok(Va == NULL, "Va = %p\n", Va);
+
+    Va = RtlImageRvaToVa(NtHeader, BaseAddress, 0, NULL);
+    ok(Va == NULL, "Va = %p\n", Va);
+
+    OutSection = NULL;
+    Va = RtlImageRvaToVa(NtHeader, BaseAddress, 0, &OutSection);
+    ok(Va == NULL, "Va = %p\n", Va);
+    ok(OutSection == NULL, "OutSection = %p\n", OutSection);
+
+    OutSection = (PVOID)1;
+    StartSeh()
+        RtlImageRvaToVa(NtHeader, BaseAddress, 0, &OutSection);
+    EndSeh(STATUS_ACCESS_VIOLATION);
+
+    for (i = 0; i < RTL_NUMBER_OF(Tests); i++)
+    {
+        /* Section = not specified */
+        StartSeh()
+            Va = RtlImageRvaToVa(NtHeader, BaseAddress, Tests[i].Rva, NULL);
+        EndSeh(STATUS_SUCCESS);
+        if (Tests[i].VaOffset == 0)
+            ok(Va == NULL, "[0x%lx] Va = %p\n", Tests[i].Rva, Va);
+        else
+            ok(Va == BaseAddress + Tests[i].VaOffset, "[0x%lx] Va = %p\n", Tests[i].Rva, Va);
+
+        /* Section = NULL */
+        OutSection = NULL;
+        StartSeh()
+            Va = RtlImageRvaToVa(NtHeader, BaseAddress, Tests[i].Rva, &OutSection);
+        EndSeh(STATUS_SUCCESS);
+        if (Tests[i].VaOffset == 0)
+        {
+            ok(Va == NULL, "[0x%lx] Va = %p\n", Tests[i].Rva, Va);
+            ok(OutSection == NULL, "[0x%lx] OutSection = %p (%Id)\n", Tests[i].Rva, OutSection, OutSection - Section);
+        }
+        else
+        {
+            ok(Va == BaseAddress + Tests[i].VaOffset, "[0x%lx] Va = %p\n", Tests[i].Rva, Va);
+            ok(OutSection == &Section[Tests[i].SectionIndex], "[0x%lx] OutSection = %p (%Id)\n", Tests[i].Rva, OutSection, OutSection - Section);
+        }
+
+        /* Section = first section */
+        OutSection = Section;
+        StartSeh()
+            Va = RtlImageRvaToVa(NtHeader, BaseAddress, Tests[i].Rva, &OutSection);
+        EndSeh(STATUS_SUCCESS);
+        if (Tests[i].VaOffset == 0)
+        {
+            ok(Va == NULL, "[0x%lx] Va = %p\n", Tests[i].Rva, Va);
+            ok(OutSection == Section, "[0x%lx] OutSection = %p (%Id)\n", Tests[i].Rva, OutSection, OutSection - Section);
+        }
+        else
+        {
+            ok(Va == BaseAddress + Tests[i].VaOffset, "[0x%lx] Va = %p\n", Tests[i].Rva, Va);
+            ok(OutSection == &Section[Tests[i].SectionIndex], "[0x%lx] OutSection = %p (%Id)\n", Tests[i].Rva, OutSection, OutSection - Section);
+        }
+
+        /* Section = dummy section */
+        OutSection = &DummySection;
+        StartSeh()
+            Va = RtlImageRvaToVa(NtHeader, BaseAddress, Tests[i].Rva, &OutSection);
+        EndSeh(STATUS_SUCCESS);
+        if (Tests[i].VaOffset == 0)
+        {
+            ok(Va == NULL, "[0x%lx] Va = %p\n", Tests[i].Rva, Va);
+            ok(OutSection == &DummySection, "[0x%lx] OutSection = %p (%Id)\n", Tests[i].Rva, OutSection, OutSection - Section);
+        }
+        else
+        {
+            ok(Va == BaseAddress + Tests[i].VaOffset, "[0x%lx] Va = %p\n", Tests[i].Rva, Va);
+            ok(OutSection == &Section[Tests[i].SectionIndex], "[0x%lx] OutSection = %p (%Id)\n", Tests[i].Rva, OutSection, OutSection - Section);
+        }
+    }
+
+    FreeGuarded(NtHeader);
+}

diff --git a/rostests/apitests/ntdll/testlist.c b/rostests/apitests/ntdll/testlist.c
index 2f94af4..08dc8c7 100644 (file)
--- a/rostests/apitests/ntdll/testlist.c
+++ b/rostests/apitests/ntdll/testlist.c
@@ -35,6 +35,7 @@ extern void func_RtlGetFullPathName_Ustr(void);
 extern void func_RtlGetFullPathName_UstrEx(void);
 extern void func_RtlGetLengthWithoutTrailingPathSeperators(void);
 extern void func_RtlGetLongestNtPathLength(void);
+extern void func_RtlImageRvaToVa(void);
 extern void func_RtlInitializeBitMap(void);
 extern void func_RtlMemoryStream(void);
 extern void func_RtlReAllocateHeap(void);
@@ -75,6 +76,7 @@ const struct test winetest_testlist[] =
     { "RtlGetFullPathName_UstrEx",      func_RtlGetFullPathName_UstrEx },
     { "RtlGetLengthWithoutTrailingPathSeperators", func_RtlGetLengthWithoutTrailingPathSeperators },
     { "RtlGetLongestNtPathLength",      func_RtlGetLongestNtPathLength },
+    { "RtlImageRvaToVa",                func_RtlImageRvaToVa },
     { "RtlInitializeBitMap",            func_RtlInitializeBitMap },
     { "RtlMemoryStream",                func_RtlMemoryStream },
     { "RtlReAllocateHeap",              func_RtlReAllocateHeap },