Milestone 5: deliver embedded RDP sessions and lifecycle hardening

third_party/FreeRDP/winpr/libwinpr/crt/test/CMakeLists.txt

@@ -0,0 +1,23 @@
+set(MODULE_NAME "TestCrt")
+set(MODULE_PREFIX "TEST_CRT")
+
+disable_warnings_for_directory(${CMAKE_CURRENT_BINARY_DIR})
+
+set(${MODULE_PREFIX}_DRIVER ${MODULE_NAME}.c)
+
+set(${MODULE_PREFIX}_TESTS TestTypes.c TestFormatSpecifiers.c TestAlignment.c TestString.c TestUnicodeConversion.c)
+
+create_test_sourcelist(${MODULE_PREFIX}_SRCS ${${MODULE_PREFIX}_DRIVER} ${${MODULE_PREFIX}_TESTS})
+
+add_executable(${MODULE_NAME} ${${MODULE_PREFIX}_SRCS})
+
+target_link_libraries(${MODULE_NAME} winpr)
+
+set_target_properties(${MODULE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TESTING_OUTPUT_DIRECTORY}")
+
+foreach(test ${${MODULE_PREFIX}_TESTS})
+  get_filename_component(TestName ${test} NAME_WE)
+  add_test(${TestName} ${TESTING_OUTPUT_DIRECTORY}/${MODULE_NAME} ${TestName})
+endforeach()
+
+set_property(TARGET ${MODULE_NAME} PROPERTY FOLDER "WinPR/Test")

third_party/FreeRDP/winpr/libwinpr/crt/test/TestAlignment.c

@@ -0,0 +1,87 @@
+
+#include <stdio.h>
+#include <winpr/crt.h>
+#include <winpr/windows.h>
+
+int TestAlignment(int argc, char* argv[])
+{
+	void* ptr = nullptr;
+	size_t alignment = 0;
+	size_t offset = 0;
+
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	/* Alignment should be 2^N where N is a positive integer */
+
+	alignment = 16;
+	offset = 8;
+
+	/* _aligned_malloc */
+
+	ptr = winpr_aligned_malloc(100, alignment);
+
+	if (ptr == nullptr)
+	{
+		printf("Error allocating aligned memory.\n");
+		return -1;
+	}
+
+	if (((size_t)ptr % alignment) != 0)
+	{
+		printf("This pointer, %p, is not aligned on %" PRIuz "\n", ptr, alignment);
+		return -1;
+	}
+
+	/* _aligned_realloc */
+
+	ptr = winpr_aligned_realloc(ptr, 200, alignment);
+
+	if (((size_t)ptr % alignment) != 0)
+	{
+		printf("This pointer, %p, is not aligned on %" PRIuz "\n", ptr, alignment);
+		return -1;
+	}
+
+	winpr_aligned_free(ptr);
+
+	/* _aligned_offset_malloc */
+
+	ptr = winpr_aligned_offset_malloc(200, alignment, offset);
+
+	if (ptr == nullptr)
+	{
+		printf("Error reallocating aligned offset memory.");
+		return -1;
+	}
+
+	if (((((size_t)ptr) + offset) % alignment) != 0)
+	{
+		printf("This pointer, %p, does not satisfy offset %" PRIuz " and alignment %" PRIuz "\n",
+		       ptr, offset, alignment);
+		return -1;
+	}
+
+	/* _aligned_offset_realloc */
+
+	ptr = winpr_aligned_offset_realloc(ptr, 200, alignment, offset);
+
+	if (ptr == nullptr)
+	{
+		printf("Error reallocating aligned offset memory.");
+		return -1;
+	}
+
+	if (((((size_t)ptr) + offset) % alignment) != 0)
+	{
+		printf("This pointer, %p, does not satisfy offset %" PRIuz " and alignment %" PRIuz "\n",
+		       ptr, offset, alignment);
+		return -1;
+	}
+
+	/* _aligned_free works for both _aligned_malloc and _aligned_offset_malloc. free() should not be
+	 * used. */
+	winpr_aligned_free(ptr);
+
+	return 0;
+}

third_party/FreeRDP/winpr/libwinpr/crt/test/TestFormatSpecifiers.c

@@ -0,0 +1,169 @@
+#include <stdio.h>
+#include <winpr/wtypes.h>
+#include <winpr/string.h>
+
+int TestFormatSpecifiers(int argc, char* argv[])
+{
+	unsigned errors = 0;
+
+	char fmt[4096];
+
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	/* size_t */
+	{
+		size_t arg = 0xabcd;
+		const char* chk = "uz:43981 oz:125715 xz:abcd Xz:ABCD";
+
+		(void)sprintf_s(fmt, sizeof(fmt), "uz:%" PRIuz " oz:%" PRIoz " xz:%" PRIxz " Xz:%" PRIXz "",
+		                arg, arg, arg, arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed size_t test: got [%s] instead of [%s]\n", __func__,
+			              fmt, chk);
+			errors++;
+		}
+	}
+
+	/* INT8 */
+	{
+		INT8 arg = -16;
+		const char* chk = "d8:-16 x8:f0 X8:F0";
+
+		(void)sprintf_s(fmt, sizeof(fmt), "d8:%" PRId8 " x8:%" PRIx8 " X8:%" PRIX8 "", arg,
+		                (UINT8)arg, (UINT8)arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed INT8 test: got [%s] instead of [%s]\n", __func__, fmt,
+			              chk);
+			errors++;
+		}
+	}
+
+	/* UINT8 */
+	{
+		UINT8 arg = 0xFE;
+		const char* chk = "u8:254 o8:376 x8:fe X8:FE";
+
+		(void)sprintf_s(fmt, sizeof(fmt), "u8:%" PRIu8 " o8:%" PRIo8 " x8:%" PRIx8 " X8:%" PRIX8 "",
+		                arg, arg, arg, arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed UINT8 test: got [%s] instead of [%s]\n", __func__, fmt,
+			              chk);
+			errors++;
+		}
+	}
+
+	/* INT16 */
+	{
+		INT16 arg = -16;
+		const char* chk = "d16:-16 x16:fff0 X16:FFF0";
+
+		(void)sprintf_s(fmt, sizeof(fmt), "d16:%" PRId16 " x16:%" PRIx16 " X16:%" PRIX16 "", arg,
+		                (UINT16)arg, (UINT16)arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed INT16 test: got [%s] instead of [%s]\n", __func__, fmt,
+			              chk);
+			errors++;
+		}
+	}
+
+	/* UINT16 */
+	{
+		UINT16 arg = 0xFFFE;
+		const char* chk = "u16:65534 o16:177776 x16:fffe X16:FFFE";
+
+		(void)sprintf_s(fmt, sizeof(fmt),
+		                "u16:%" PRIu16 " o16:%" PRIo16 " x16:%" PRIx16 " X16:%" PRIX16 "", arg, arg,
+		                arg, arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed UINT16 test: got [%s] instead of [%s]\n", __func__,
+			              fmt, chk);
+			errors++;
+		}
+	}
+
+	/* INT32 */
+	{
+		INT32 arg = -16;
+		const char* chk = "d32:-16 x32:fffffff0 X32:FFFFFFF0";
+
+		(void)sprintf_s(fmt, sizeof(fmt), "d32:%" PRId32 " x32:%" PRIx32 " X32:%" PRIX32 "", arg,
+		                (UINT32)arg, (UINT32)arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed INT32 test: got [%s] instead of [%s]\n", __func__, fmt,
+			              chk);
+			errors++;
+		}
+	}
+
+	/* UINT32 */
+	{
+		UINT32 arg = 0xFFFFFFFE;
+		const char* chk = "u32:4294967294 o32:37777777776 x32:fffffffe X32:FFFFFFFE";
+
+		(void)sprintf_s(fmt, sizeof(fmt),
+		                "u32:%" PRIu32 " o32:%" PRIo32 " x32:%" PRIx32 " X32:%" PRIX32 "", arg, arg,
+		                arg, arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed UINT16 test: got [%s] instead of [%s]\n", __func__,
+			              fmt, chk);
+			errors++;
+		}
+	}
+
+	/* INT64 */
+	{
+		INT64 arg = -16;
+		const char* chk = "d64:-16 x64:fffffffffffffff0 X64:FFFFFFFFFFFFFFF0";
+
+		(void)sprintf_s(fmt, sizeof(fmt), "d64:%" PRId64 " x64:%" PRIx64 " X64:%" PRIX64 "", arg,
+		                (UINT64)arg, (UINT64)arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed INT64 test: got [%s] instead of [%s]\n", __func__, fmt,
+			              chk);
+			errors++;
+		}
+	}
+
+	/* UINT64 */
+	{
+		UINT64 arg = 0xFFFFFFFFFFFFFFFE;
+		const char* chk = "u64:18446744073709551614 o64:1777777777777777777776 "
+		                  "x64:fffffffffffffffe X64:FFFFFFFFFFFFFFFE";
+
+		(void)sprintf_s(fmt, sizeof(fmt),
+		                "u64:%" PRIu64 " o64:%" PRIo64 " x64:%016" PRIx64 " X64:%016" PRIX64 "",
+		                arg, arg, arg, arg);
+
+		if (strcmp(fmt, chk) != 0)
+		{
+			(void)fprintf(stderr, "%s failed UINT64 test: got [%s] instead of [%s]\n", __func__,
+			              fmt, chk);
+			errors++;
+		}
+	}
+
+	if (errors)
+	{
+		(void)fprintf(stderr, "%s produced %u errors\n", __func__, errors);
+		return -1;
+	}
+
+	return 0;
+}

third_party/FreeRDP/winpr/libwinpr/crt/test/TestString.c

@@ -0,0 +1,222 @@
+
+#include <stdio.h>
+#include <winpr/crt.h>
+#include <winpr/string.h>
+#include <winpr/windows.h>
+
+static const CHAR testStringA[] = { 'T', 'h', 'e', ' ', 'q', 'u', 'i', 'c', 'k', ' ', 'b',
+	                                'r', 'o', 'w', 'n', ' ', 'f', 'o', 'x', ' ', 'j', 'u',
+	                                'm', 'p', 's', ' ', 'o', 'v', 'e', 'r', ' ', 't', 'h',
+	                                'e', ' ', 'l', 'a', 'z', 'y', ' ', 'd', 'o', 'g', '\0' };
+
+#define testStringA_Length ((sizeof(testStringA) / sizeof(CHAR)) - 1)
+
+static const CHAR testToken1A[] = { 'q', 'u', 'i', 'c', 'k', '\0' };
+static const CHAR testToken2A[] = { 'b', 'r', 'o', 'w', 'n', '\0' };
+static const CHAR testToken3A[] = { 'f', 'o', 'x', '\0' };
+
+#define testToken1A_Length ((sizeof(testToken1A) / sizeof(CHAR)) - 1)
+#define testToken2A_Length ((sizeof(testToken2A) / sizeof(CHAR)) - 1)
+#define testToken3A_Length ((sizeof(testToken3A) / sizeof(CHAR)) - 1)
+
+static const CHAR testTokensA[] = { 'q', 'u', 'i',  'c',  'k', '\r', '\n', 'b',  'r',  'o',
+	                                'w', 'n', '\r', '\n', 'f', 'o',  'x',  '\r', '\n', '\0' };
+
+#define testTokensA_Length ((sizeof(testTokensA) / sizeof(CHAR)) - 1)
+
+static const CHAR testDelimiterA[] = { '\r', '\n', '\0' };
+
+#define testDelimiterA_Length ((sizeof(testDelimiter) / sizeof(CHAR)) - 1)
+
+struct url_test_pair
+{
+	const char* what;
+	const char* escaped;
+};
+
+static const struct url_test_pair url_tests[] = {
+	{ "xxx%bar ga<ka>ee#%%#%{h}g{f{e%d|c\\b^a~p[q]r`s;t/u?v:w@x=y&z$xxx",
+	  "xxx%25bar%20ga%3Cka%3Eee%23%25%25%23%25%7Bh%7Dg%7Bf%7Be%25d%7Cc%5Cb%5Ea~p%5Bq%5Dr%60s%3Bt%"
+	  "2Fu%3Fv%3Aw%40x%3Dy%26z%24xxx" },
+	{ "äöúëü", "%C3%A4%C3%B6%C3%BA%C3%AB%C3%BC" },
+	{ "🎅🏄🤘😈", "%F0%9F%8E%85%F0%9F%8F%84%F0%9F%A4%98%F0%9F%98%88" },
+	{ "foo$.%.^.&.\\.txt+", "foo%24.%25.%5E.%26.%5C.txt%2B" }
+};
+
+static BOOL test_url_escape(void)
+{
+	for (size_t x = 0; x < ARRAYSIZE(url_tests); x++)
+	{
+		const struct url_test_pair* cur = &url_tests[x];
+
+		char* escaped = winpr_str_url_encode(cur->what, strlen(cur->what) + 1);
+		char* what = winpr_str_url_decode(cur->escaped, strlen(cur->escaped) + 1);
+
+		const size_t elen = strlen(escaped);
+		const size_t wlen = strlen(what);
+		const size_t pelen = strlen(cur->escaped);
+		const size_t pwlen = strlen(cur->what);
+		BOOL rc = TRUE;
+		if (!escaped || (elen != pelen) || (strcmp(escaped, cur->escaped) != 0))
+		{
+			printf("expected: [%" PRIuz "] %s\n", pelen, cur->escaped);
+			printf("got     : [%" PRIuz "] %s\n", elen, escaped);
+			rc = FALSE;
+		}
+		else if (!what || (wlen != pwlen) || (strcmp(what, cur->what) != 0))
+		{
+			printf("expected: [%" PRIuz "] %s\n", pwlen, cur->what);
+			printf("got     : [%" PRIuz "] %s\n", wlen, what);
+			rc = FALSE;
+		}
+
+		free(escaped);
+		free(what);
+		if (!rc)
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static BOOL test_winpr_asprintf(void)
+{
+	BOOL rc = FALSE;
+	const char test[] = "test string case";
+	const size_t len = strnlen(test, sizeof(test));
+
+	char* str = nullptr;
+	size_t slen = 0;
+	const int res = winpr_asprintf(&str, &slen, "%s", test);
+	if (!str)
+		goto fail;
+	if (res < 0)
+		goto fail;
+	if ((size_t)res != len)
+		goto fail;
+	if (len != slen)
+		goto fail;
+	if (strnlen(str, slen + 10) != slen)
+		goto fail;
+	rc = TRUE;
+fail:
+	free(str);
+	return rc;
+}
+
+int TestString(int argc, char* argv[])
+{
+	const WCHAR* p = nullptr;
+	size_t pos = 0;
+	size_t length = 0;
+	WCHAR* context = nullptr;
+
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	if (!test_winpr_asprintf())
+		return -1;
+
+	if (!test_url_escape())
+		return -1;
+
+	/* _wcslen */
+	WCHAR testStringW[ARRAYSIZE(testStringA)] = WINPR_C_ARRAY_INIT;
+	(void)ConvertUtf8NToWChar(testStringA, ARRAYSIZE(testStringA), testStringW,
+	                          ARRAYSIZE(testStringW));
+	const size_t testStringW_Length = testStringA_Length;
+	length = _wcslen(testStringW);
+
+	if (length != testStringW_Length)
+	{
+		printf("_wcslen error: length mismatch: Actual: %" PRIuz ", Expected: %" PRIuz "\n", length,
+		       testStringW_Length);
+		return -1;
+	}
+
+	/* _wcschr */
+	union
+	{
+		char c[2];
+		WCHAR w;
+	} search;
+	search.c[0] = 'r';
+	search.c[1] = '\0';
+
+	p = _wcschr(testStringW, search.w);
+	pos = (p - testStringW);
+
+	if (pos != 11)
+	{
+		printf("_wcschr error: position mismatch: Actual: %" PRIuz ", Expected: 11\n", pos);
+		return -1;
+	}
+
+	p = _wcschr(&testStringW[pos + 1], search.w);
+	pos = (p - testStringW);
+
+	if (pos != 29)
+	{
+		printf("_wcschr error: position mismatch: Actual: %" PRIuz ", Expected: 29\n", pos);
+		return -1;
+	}
+
+	p = _wcschr(&testStringW[pos + 1], search.w);
+
+	if (p != nullptr)
+	{
+		printf("_wcschr error: return value mismatch: Actual: %p, Expected: nullptr\n",
+		       (const void*)p);
+		return -1;
+	}
+
+	/* wcstok_s */
+	WCHAR testDelimiterW[ARRAYSIZE(testDelimiterA)] = WINPR_C_ARRAY_INIT;
+	WCHAR testTokensW[ARRAYSIZE(testTokensA)] = WINPR_C_ARRAY_INIT;
+	(void)ConvertUtf8NToWChar(testTokensA, ARRAYSIZE(testTokensA), testTokensW,
+	                          ARRAYSIZE(testTokensW));
+	(void)ConvertUtf8NToWChar(testDelimiterA, ARRAYSIZE(testDelimiterA), testDelimiterW,
+	                          ARRAYSIZE(testDelimiterW));
+	p = wcstok_s(testTokensW, testDelimiterW, &context);
+
+	WCHAR testToken1W[ARRAYSIZE(testToken1A)] = WINPR_C_ARRAY_INIT;
+	(void)ConvertUtf8NToWChar(testToken1A, ARRAYSIZE(testToken1A), testToken1W,
+	                          ARRAYSIZE(testToken1W));
+	if (memcmp(p, testToken1W, sizeof(testToken1W)) != 0)
+	{
+		printf("wcstok_s error: token #1 mismatch\n");
+		return -1;
+	}
+
+	p = wcstok_s(nullptr, testDelimiterW, &context);
+
+	WCHAR testToken2W[ARRAYSIZE(testToken2A)] = WINPR_C_ARRAY_INIT;
+	(void)ConvertUtf8NToWChar(testToken2A, ARRAYSIZE(testToken2A), testToken2W,
+	                          ARRAYSIZE(testToken2W));
+	if (memcmp(p, testToken2W, sizeof(testToken2W)) != 0)
+	{
+		printf("wcstok_s error: token #2 mismatch\n");
+		return -1;
+	}
+
+	p = wcstok_s(nullptr, testDelimiterW, &context);
+
+	WCHAR testToken3W[ARRAYSIZE(testToken3A)] = WINPR_C_ARRAY_INIT;
+	(void)ConvertUtf8NToWChar(testToken3A, ARRAYSIZE(testToken3A), testToken3W,
+	                          ARRAYSIZE(testToken3W));
+	if (memcmp(p, testToken3W, sizeof(testToken3W)) != 0)
+	{
+		printf("wcstok_s error: token #3 mismatch\n");
+		return -1;
+	}
+
+	p = wcstok_s(nullptr, testDelimiterW, &context);
+
+	if (p != nullptr)
+	{
+		printf("wcstok_s error: return value is not nullptr\n");
+		return -1;
+	}
+
+	return 0;
+}

third_party/FreeRDP/winpr/libwinpr/crt/test/TestTypes.c

@@ -0,0 +1,115 @@
+
+#include <stdio.h>
+#include <winpr/crt.h>
+#include <winpr/windows.h>
+
+#define EXPECTED_SIZEOF_BYTE 1
+#define EXPECTED_SIZEOF_BOOLEAN 1
+#define EXPECTED_SIZEOF_CHAR 1
+#define EXPECTED_SIZEOF_UCHAR 1
+#define EXPECTED_SIZEOF_INT8 1
+#define EXPECTED_SIZEOF_UINT8 1
+#define EXPECTED_SIZEOF_INT16 2
+#define EXPECTED_SIZEOF_UINT16 2
+#define EXPECTED_SIZEOF_WORD 2
+#define EXPECTED_SIZEOF_WCHAR 2
+#define EXPECTED_SIZEOF_SHORT 2
+#define EXPECTED_SIZEOF_USHORT 2
+#define EXPECTED_SIZEOF_BOOL 4
+#define EXPECTED_SIZEOF_INT 4
+#define EXPECTED_SIZEOF_UINT 4
+#define EXPECTED_SIZEOF_INT32 4
+#define EXPECTED_SIZEOF_UINT32 4
+#define EXPECTED_SIZEOF_DWORD 4
+#define EXPECTED_SIZEOF_DWORD32 4
+#define EXPECTED_SIZEOF_LONG 4
+#define EXPECTED_SIZEOF_LONG32 4
+#define EXPECTED_SIZEOF_INT64 8
+#define EXPECTED_SIZEOF_UINT64 8
+#define EXPECTED_SIZEOF_DWORD64 8
+#define EXPECTED_SIZEOF_DWORDLONG 8
+#define EXPECTED_SIZEOF_LONG64 8
+#define EXPECTED_SIZEOF_ULONGLONG 8
+#define EXPECTED_SIZEOF_LUID 8
+#define EXPECTED_SIZEOF_FILETIME 8
+#define EXPECTED_SIZEOF_LARGE_INTEGER 8
+#define EXPECTED_SIZEOF_ULARGE_INTEGER 8
+#define EXPECTED_SIZEOF_GUID 16
+#define EXPECTED_SIZEOF_SYSTEMTIME 16
+#define EXPECTED_SIZEOF_size_t sizeof(void*)
+#define EXPECTED_SIZEOF_INT_PTR sizeof(void*)
+#define EXPECTED_SIZEOF_UINT_PTR sizeof(void*)
+#define EXPECTED_SIZEOF_DWORD_PTR sizeof(void*)
+#define EXPECTED_SIZEOF_LONG_PTR sizeof(void*)
+#define EXPECTED_SIZEOF_ULONG_PTR sizeof(void*)
+
+#define TEST_SIZEOF_TYPE(_name)                                                                  \
+	if (sizeof(_name) != EXPECTED_SIZEOF_##_name)                                                \
+	{                                                                                            \
+		(void)fprintf(stderr, "sizeof(%s) mismatch: Actual: %" PRIuz ", Expected: %" PRIuz "\n", \
+		              #_name, sizeof(_name), (size_t)EXPECTED_SIZEOF_##_name);                   \
+		status = -1;                                                                             \
+	}
+
+int TestTypes(int argc, char* argv[])
+{
+	int status = 0;
+
+	WINPR_UNUSED(argc);
+	WINPR_UNUSED(argv);
+
+	TEST_SIZEOF_TYPE(INT8)
+	TEST_SIZEOF_TYPE(UINT8)
+
+	TEST_SIZEOF_TYPE(BYTE)
+	TEST_SIZEOF_TYPE(BOOLEAN)
+	TEST_SIZEOF_TYPE(CHAR)
+	TEST_SIZEOF_TYPE(UCHAR)
+
+	TEST_SIZEOF_TYPE(INT16)
+	TEST_SIZEOF_TYPE(UINT16)
+
+	TEST_SIZEOF_TYPE(WORD)
+	TEST_SIZEOF_TYPE(WCHAR)
+	TEST_SIZEOF_TYPE(SHORT)
+	TEST_SIZEOF_TYPE(USHORT)
+
+	/* fails on OS X */
+	// TEST_SIZEOF_TYPE(BOOL)
+
+	TEST_SIZEOF_TYPE(INT)
+	TEST_SIZEOF_TYPE(UINT)
+	TEST_SIZEOF_TYPE(DWORD)
+	TEST_SIZEOF_TYPE(DWORD32)
+	TEST_SIZEOF_TYPE(LONG)
+	TEST_SIZEOF_TYPE(LONG32)
+
+	TEST_SIZEOF_TYPE(INT32)
+	TEST_SIZEOF_TYPE(UINT32)
+
+	TEST_SIZEOF_TYPE(INT64)
+	TEST_SIZEOF_TYPE(UINT64)
+
+	TEST_SIZEOF_TYPE(DWORD64)
+	TEST_SIZEOF_TYPE(DWORDLONG)
+
+	TEST_SIZEOF_TYPE(LONG64)
+	TEST_SIZEOF_TYPE(ULONGLONG)
+
+	TEST_SIZEOF_TYPE(LUID)
+	TEST_SIZEOF_TYPE(FILETIME)
+	TEST_SIZEOF_TYPE(LARGE_INTEGER)
+	TEST_SIZEOF_TYPE(ULARGE_INTEGER)
+
+	TEST_SIZEOF_TYPE(GUID)
+	TEST_SIZEOF_TYPE(SYSTEMTIME)
+
+	TEST_SIZEOF_TYPE(size_t)
+	TEST_SIZEOF_TYPE(INT_PTR)
+	TEST_SIZEOF_TYPE(UINT_PTR)
+	TEST_SIZEOF_TYPE(DWORD_PTR)
+	TEST_SIZEOF_TYPE(LONG_PTR)
+	TEST_SIZEOF_TYPE(ULONG_PTR)
+
+	return status;
+}