vclient: Add tests for C API thunks.

build_proton.sh

@@ -384,6 +384,23 @@ function build_vrclient64
     cp -a vrclient_x64.dll.fake "$DST_DIR"/lib64/wine/fakedlls/vrclient_x64.dll
 }
 
+function build_vrclient64_tests
+{
+    build_vrclient64
+
+    cp -a vrclient_x64/flatapi.c tests/
+    $AMD64_WRAPPER "$TOP"/wine/tools/winemaker/winemaker \
+        --nosource-fix --nolower-include --nodlls --nomsvcrt \
+        -I"$TOOLS_DIR64"/include/ \
+        -I"$TOOLS_DIR64"/include/wine/ \
+        -I"$TOOLS_DIR64"/include/wine/windows/ \
+        -I../vrclient_x64/ \
+        -L"$TOOLS_DIR64"/lib64/ \
+        -L"$TOOLS_DIR64"/lib64/wine/ \
+        tests
+    CXXFLAGS="-Wno-attributes -std=c++0x -O2 -g" CFLAGS="-O2 -g" PATH="$TOOLS_DIR64/bin:$PATH" $AMD64_WRAPPER make $JOBS -C tests
+}
+
 function build_vrclient32
 {
     cd "$TOP"
@@ -410,6 +427,23 @@ function build_vrclient32
     cp -a vrclient.dll.fake "$DST_DIR"/lib/wine/fakedlls/vrclient.dll
 }
 
+function build_vrclient32_tests
+{
+    build_vrclient32
+
+    cp -a vrclient/flatapi.c tests/
+    $I386_WRAPPER "$TOP"/wine/tools/winemaker/winemaker \
+        --nosource-fix --nolower-include --nodlls --nomsvcrt \
+        -I"$TOOLS_DIR32"/include/ \
+        -I"$TOOLS_DIR32"/include/wine/ \
+        -I"$TOOLS_DIR32"/include/wine/windows/ \
+        -I../vrclient/ \
+        -L"$TOOLS_DIR32"/lib/ \
+        -L"$TOOLS_DIR32"/lib/wine/ \
+        tests
+    CXXFLAGS="-Wno-attributes -std=c++0x -O2 -g" CFLAGS="-O2 -g" PATH="$TOOLS_DIR32/bin:$PATH" $I386_WRAPPER make $JOBS -C tests
+}
+
 function build_dxvk
 {
     #unfortunately the Steam chroots are too old to build DXVK, so we have to
@@ -596,6 +630,7 @@ case "$BUILD_COMPONENTS" in
     "lsteamclient") build_lsteamclient32; build_lsteamclient64 ;;
     "lsteamclient32") build_lsteamclient32 ;;
     "lsteamclient64") build_lsteamclient64 ;;
+    "vrclient_tests") build_vrclient32_tests; build_vrclient64_tests ;;
     *) echo "Invalid build components: $BUILD_COMPONENTS" ;;
 esac
 

vrclient_x64/gen.sh

@@ -8,4 +8,7 @@ rm vrclient_x64/cpp*.h
 rm vrclient_x64/struct*.h
 rm vrclient_x64/struct*.cpp
 
+rm tests/*_autogen.c
+rm tests/*_autogen.h
+
 ./gen_wrapper.py

vrclient_x64/gen_wrapper.py

@@ -553,6 +553,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
         for alias in aliases[iface_version]:
             constructors.write("    {\"%s\", &create_%s}, /* alias */\n" % (alias, winclassname))
 
+    generate_c_api_thunk_tests(winclassname, methods, method_names)
+
 
 generated_struct_handlers = []
 cpp_files_need_close_brace = []
@@ -757,6 +759,190 @@ extern void call_flat_method_f(void);
 
         f.write("#endif\n")
 
+def generate_c_api_method_test(f, header, thunks_c, class_name, method_name, method):
+    thunk_params = get_capi_thunk_params(method)
+    f.write("\n    init_thunk(t, this_ptr_value, %s_%s, %s);\n" % (class_name, method_name, thunk_params))
+    f.write("    ")
+    header.write("\n")
+    thunks_c.write("\n")
+
+    returns_record = method.result_type.get_canonical().kind == clang.cindex.TypeKind.RECORD
+    if returns_record:
+        f.write("%s *" % strip_ns(method.result_type.spelling))
+        header.write("%s *" % strip_ns(method.result_type.spelling))
+        thunks_c.write("%s *" % strip_ns(method.result_type.spelling))
+    else:
+        f.write("%s " % strip_ns(method.result_type.spelling))
+        header.write("%s " % strip_ns(method.result_type.spelling))
+        thunks_c.write("%s " % strip_ns(method.result_type.spelling))
+    first_param = True
+    f.write('(__stdcall *capi_%s_%s)(' % (class_name, method_name))
+    header.write('__thiscall %s_%s(void *_this' % (class_name, method_name))
+    thunks_c.write('__thiscall %s_%s(void *_this' % (class_name, method_name))
+    if returns_record:
+        f.write("%s *_r" % strip_ns(method.result_type.spelling))
+        first_param = False
+        header.write(", %s *_r" % strip_ns(method.result_type.spelling))
+        thunks_c.write(", %s *_r" % strip_ns(method.result_type.spelling))
+
+    for param in get_params(method):
+        if param.type.kind == clang.cindex.TypeKind.POINTER \
+                and param.type.get_pointee().kind == clang.cindex.TypeKind.UNEXPOSED:
+            typename = "void *"
+        else:
+            typename = param.type.spelling.split("::")[-1].replace("&", "*");
+        if not first_param:
+            f.write(", ")
+        first_param = False
+        f.write("%s %s" % (typename, param.spelling))
+        header.write(", %s %s" % (typename, param.spelling))
+        thunks_c.write(", %s %s" % (typename, param.spelling))
+    f.write(") = (void *)t;\n")
+    header.write(");\n")
+    thunks_c.write(")\n{\n")
+
+    thunks_c.write("    push_ptr_parameter(_this);\n")
+    if returns_record:
+        thunks_c.write("    push_ptr_parameter(_r);\n")
+    for param in get_params(method):
+        param_size = param.type.get_size()
+        if param.type.kind == clang.cindex.TypeKind.POINTER \
+                or param.type.spelling.endswith("&") \
+                or param.type.spelling == "vr::glSharedTextureHandle_t":
+            typename = "ptr"
+        elif param.type.spelling == "bool":
+            typename = "bool"
+        elif param.type.spelling == "float":
+            typename = "float"
+        elif param.type.spelling == "vr::HmdRect2_t":
+            typename = "HmdRect2"
+        elif param.type.spelling == "vr::HmdVector2_t":
+            typename = "HmdVector2"
+        elif param.type.spelling == "vr::HmdVector3_t":
+            typename = "HmdVector3"
+        elif param.type.spelling == "vr::HmdColor_t":
+            typename = "HmdColor"
+        elif param_size == 8:
+            typename = "uint64"
+        elif param_size == 4 or param_size == 2:
+            typename = "uint32"
+        else:
+            typename = "unknown"
+        thunks_c.write("    push_%s_parameter(%s);\n" % (typename, param.spelling))
+    if method.result_type.kind != clang.cindex.TypeKind.VOID:
+        thunks_c.write("    return 0;\n")
+    thunks_c.write("}\n")
+
+    parameter_checks = []
+    def add_parameter_check(typename, value):
+        parameter_checks.append("check_%s_parameter(\"%s_%s\", %s)" % (typename, class_name, method_name, value))
+    add_parameter_check("ptr", "this_ptr_value")
+    f.write("\n")
+    f.write("    clear_parameters();\n")
+    f.write("    capi_%s_%s(" % (class_name, method_name))
+    first_param = True
+    if returns_record:
+        f.write("data_ptr_value")
+        first_param = False
+        add_parameter_check("ptr", "data_ptr_value")
+    for i, param in enumerate(get_params(method)):
+        i += 1
+        param_size = param.type.get_size()
+        if param.type.kind == clang.cindex.TypeKind.POINTER \
+                or param.type.spelling.endswith("&") \
+                or param.type.spelling == "vr::glSharedTextureHandle_t":
+            v = "(void *)%s" % i
+            add_parameter_check("ptr", v)
+        elif param.type.spelling == "bool":
+            v = "1"
+            add_parameter_check("bool", v)
+        elif param.type.spelling == "float":
+            v = "%s.0f" % i
+            add_parameter_check("float", v)
+        elif param.type.spelling == "vr::HmdRect2_t":
+            v = "DEFAULT_RECT";
+            add_parameter_check("HmdRect2", v)
+        elif param.type.spelling == "vr::HmdVector2_t":
+            v = "DEFAULT_VECTOR2";
+            add_parameter_check("HmdVector2", v)
+        elif param.type.spelling == "vr::HmdVector3_t":
+            v = "DEFAULT_VECTOR3";
+            add_parameter_check("HmdVector3", v)
+        elif param.type.spelling == "vr::HmdColor_t":
+            v = "DEFAULT_COLOR";
+            add_parameter_check("HmdColor", v)
+        elif param_size == 8:
+            v = str(i)
+            add_parameter_check("uint64", v)
+        elif param_size == 4 or param_size == 2:
+            v = str(i)
+            add_parameter_check("uint32", v)
+        if not first_param:
+            f.write(", ")
+        first_param = False
+        f.write(v)
+    f.write(");\n")
+    for c in parameter_checks:
+        f.write("    %s;\n" % c)
+
+def generate_c_api_thunk_tests(winclassname, methods, method_names):
+    class_name = re.sub(r'^win[A-Za-z]+_', '', winclassname)
+
+    filename = "tests/capi_thunks_autogen.h"
+    file_exists = os.path.isfile(filename)
+    header = open(filename, "a")
+    if not file_exists:
+        header.write("""/* This file is auto-generated, do not edit. */
+#include <stdarg.h>
+#include <stdint.h>
+
+#include "windef.h"
+#include "winbase.h"
+
+#include "cxx.h"
+#include "flatapi.h"
+#include "vrclient_defs.h"
+
+#include "capi_thunks.h"
+""")
+    header.write("\nvoid test_capi_thunks_%s(void);\n" % class_name)
+
+    filename = "tests/capi_thunks_autogen.c"
+    file_exists = os.path.isfile(filename)
+    thunks_c = open(filename, "a")
+    if not file_exists:
+        thunks_c.write("""/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+""")
+
+    filename = "tests/capi_thunks_tests_autogen.c"
+    file_exists = os.path.isfile(filename)
+    with open(filename, "a") as f:
+        if not file_exists:
+            f.write("""/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+""")
+        f.write("\nvoid test_capi_thunks_%s(void)\n{\n" % class_name)
+        f.write("    struct thunk *t = alloc_thunks(1);\n");
+        for i in range(len(methods)):
+            generate_c_api_method_test(f, header, thunks_c, class_name, method_names[i], methods[i])
+        f.write("    VirtualFree(t, 0, MEM_RELEASE);\n")
+        f.write("}\n")
+
+    filename = "tests/main_autogen.c"
+    file_exists = os.path.isfile(filename)
+    with open(filename, "a") as f:
+        if not file_exists:
+            f.write("""/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+
+#include <stdio.h>
+
+int main(void)
+{
+""")
+        f.write("    test_capi_thunks_%s();\n" % class_name)
+
 
 #clang.cindex.Config.set_library_file("/usr/lib/llvm-3.8/lib/libclang-3.8.so.1");
 
@@ -806,4 +992,8 @@ for f in cpp_files_need_close_brace:
     m = open(f, "a")
     m.write("\n}\n")
 
+with open("tests/main_autogen.c", "a") as f:
+    f.write("    printf(\"All tests executed.\\n\");\n")
+    f.write("}\n")
+
 generate_flatapi_c()

vrclient_x64/tests/capi_thunks.c

@@ -0,0 +1,289 @@
+#include "capi_thunks_autogen.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAX_PARAMETERS 20
+
+HmdRect2_t DEFAULT_RECT;
+HmdVector2_t DEFAULT_VECTOR2;
+HmdVector3_t DEFAULT_VECTOR3;
+HmdColor_t DEFAULT_COLOR;
+
+enum parameter_type
+{
+    PT_PTR,
+    PT_BOOL,
+    PT_FLOAT,
+    PT_UINT32,
+    PT_UINT64,
+    PT_HMDRECT2,
+    PT_HMDVECTOR2,
+    PT_HMDVECTOR3,
+    PT_HMDCOLOR,
+};
+
+struct parameter
+{
+    enum parameter_type pt;
+    union
+    {
+        const void *ptr;
+        bool b;
+        float f;
+        uint32_t u32;
+        uint64_t u64;
+        HmdRect2_t hmd_rect2;
+        HmdVector2_t hmd_vector2;
+        HmdVector3_t hmd_vector3;
+        HmdColor_t hmd_color;
+    } value;
+};
+
+static struct
+{
+    unsigned int parameter_index;
+    unsigned int parameter_count;
+    struct parameter parameters[MAX_PARAMETERS];
+}
+params;
+
+void clear_parameters(void)
+{
+    memset(&params, 0, sizeof(params));
+}
+
+struct parameter *get_next_parameter(void)
+{
+    assert(params.parameter_count < MAX_PARAMETERS);
+    return &params.parameters[params.parameter_count++];
+}
+
+struct parameter *get_pushed_parameter(void)
+{
+    assert(params.parameter_index < params.parameter_count);
+    return &params.parameters[params.parameter_index++];
+}
+
+void push_ptr_parameter(const void *v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_PTR;
+    param->value.ptr = v;
+}
+
+void push_bool_parameter(bool b)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_BOOL;
+    param->value.b = b;
+}
+
+void push_float_parameter(float f)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_FLOAT;
+    param->value.f = f;
+}
+
+void push_uint32_parameter(uint32_t u)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_UINT32;
+    param->value.u32 = u;
+}
+
+void push_uint64_parameter(uint64_t u)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_UINT64;
+    param->value.u64 = u;
+}
+
+void push_HmdRect2_parameter(HmdRect2_t v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_HMDRECT2;
+    param->value.hmd_rect2 = v;
+}
+
+void push_HmdVector2_parameter(HmdVector2_t v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_HMDVECTOR2;
+    param->value.hmd_vector2 = v;
+}
+
+void push_HmdVector3_parameter(HmdVector3_t v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_HMDVECTOR3;
+    param->value.hmd_vector3 = v;
+
+}
+
+void push_HmdColor_parameter(HmdColor_t v)
+{
+    struct parameter *param = get_next_parameter();
+
+    param->pt = PT_HMDCOLOR;
+    param->value.hmd_color = v;
+}
+
+void check_ptr_parameter_(const char *file, unsigned int line, const char *name, const void *v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_PTR)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.ptr != v)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %p, expected %p.\n", file, line, name, i, param->value.ptr, v);
+        exit(-1);
+    }
+}
+
+void check_bool_parameter_(const char *file, unsigned int line, const char *name, bool b)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_BOOL)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.b != b)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %#x, expected %#x.\n", file, line, name, i, param->value.b, b);
+        exit(-1);
+    }
+}
+
+void check_float_parameter_(const char *file, unsigned int line, const char *name, float f)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_FLOAT)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.f != f)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %.8ex, expected %.8ex.\n", file, line, name, i, param->value.f, f);
+        exit(-1);
+    }
+}
+
+void check_uint32_parameter_(const char *file, unsigned int line, const char *name, uint32_t u)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_UINT32)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.u32 != u)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %"PRIu32", expected %"PRIu32".\n",
+                file, line, name, i, param->value.u32, u);
+        exit(-1);
+    }
+}
+
+void check_uint64_parameter_(const char *file, unsigned int line, const char *name, uint64_t u)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_UINT64)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    if (param->value.u64 != u)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Got %"PRIu64", expected %"PRIu64".\n",
+                file, line, name, i, param->value.u64, u);
+        exit(-1);
+    }
+}
+
+void check_HmdRect2_parameter_(const char *file, unsigned int line, const char *name, HmdRect2_t v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_HMDRECT2)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    fprintf(stderr, "TODO: compare HmdRect2\n");
+}
+
+void check_HmdVector2_parameter_(const char *file, unsigned int line, const char *name, HmdVector2_t v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_HMDVECTOR2)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    fprintf(stderr, "TODO: compare HmdVector2\n");
+}
+
+void check_HmdVector3_parameter_(const char *file, unsigned int line, const char *name, HmdVector3_t v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_HMDVECTOR3)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    fprintf(stderr, "TODO: compare HmdVector3\n");
+}
+
+void check_HmdColor_parameter_(const char *file, unsigned int line, const char *name, HmdColor_t v)
+{
+    unsigned int i = params.parameter_index;
+    struct parameter *param = get_pushed_parameter();
+
+    if (param->pt != PT_HMDCOLOR)
+    {
+        fprintf(stderr, "%s:%u, %s, %u: Invalid parameter type %#x.\n", file, line, name, i, param->pt);
+        exit(-1);
+    }
+
+    fprintf(stderr, "TODO: compare HmdColor\n");
+}

vrclient_x64/tests/capi_thunks.h

@@ -0,0 +1,43 @@
+#ifdef __i386__
+# define this_ptr_value ((void *)0xdeadbeef)
+#else
+# define this_ptr_value ((void *)0xdeadbeefdeadc0de)
+#endif
+
+#define data_ptr_value ((void *)0xd474)
+
+extern void clear_parameters(void);
+
+extern HmdRect2_t DEFAULT_RECT;
+extern HmdVector2_t DEFAULT_VECTOR2;
+extern HmdVector3_t DEFAULT_VECTOR3;
+extern HmdColor_t DEFAULT_COLOR;
+
+extern void push_ptr_parameter(const void *v);
+extern void push_bool_parameter(bool b);
+extern void push_float_parameter(float f);
+extern void push_uint32_parameter(uint32_t u);
+extern void push_uint64_parameter(uint64_t u);
+extern void push_HmdRect2_parameter(HmdRect2_t v);
+extern void push_HmdVector2_parameter(HmdVector2_t v);
+extern void push_HmdVector3_parameter(HmdVector3_t v);
+extern void push_HmdColor_parameter(HmdColor_t v);
+
+#define check_ptr_parameter(a, b) check_ptr_parameter_(__FILE__, __LINE__, a, b)
+extern void check_ptr_parameter_(const char *file, unsigned int line, const char *name, const void *v);
+#define check_bool_parameter(a, b) check_bool_parameter_(__FILE__, __LINE__, a, b)
+extern void check_bool_parameter_(const char *file, unsigned int line, const char *name, bool b);
+#define check_float_parameter(a, b) check_float_parameter_(__FILE__, __LINE__, a, b)
+extern void check_float_parameter_(const char *file, unsigned int line, const char *name, float f);
+#define check_uint32_parameter(a, b) check_uint32_parameter_(__FILE__, __LINE__, a, b)
+extern void check_uint32_parameter_(const char *file, unsigned int line, const char *name, uint32_t u);
+#define check_uint64_parameter(a, b) check_uint64_parameter_(__FILE__, __LINE__, a, b)
+extern void check_uint64_parameter_(const char *file, unsigned int line, const char *name, uint64_t u);
+#define check_HmdRect2_parameter(a, b) check_HmdRect2_parameter_(__FILE__, __LINE__, a, b)
+extern void check_HmdRect2_parameter_(const char *file, unsigned int line, const char *name, HmdRect2_t v);
+#define check_HmdVector2_parameter(a, b) check_HmdVector2_parameter_(__FILE__, __LINE__, a, b)
+extern void check_HmdVector2_parameter_(const char *file, unsigned int line, const char *name, HmdVector2_t v);
+#define check_HmdVector3_parameter(a, b) check_HmdVector3_parameter_(__FILE__, __LINE__, a, b)
+extern void check_HmdVector3_parameter_(const char *file, unsigned int line, const char *name, HmdVector3_t v);
+#define check_HmdColor_parameter(a, b) check_HmdColor_parameter_(__FILE__, __LINE__, a, b)
+extern void check_HmdColor_parameter_(const char *file, unsigned int line, const char *name, HmdColor_t v);

vrclient_x64/tests/main_autogen.c

@@ -0,0 +1,83 @@
+/* This file is auto-generated, do not edit. */
+#include "capi_thunks_autogen.h"
+
+#include <stdio.h>
+
+int main(void)
+{
+    test_capi_thunks_IVRSystem_019();
+    test_capi_thunks_IVRApplications_006();
+    test_capi_thunks_IVRSettings_002();
+    test_capi_thunks_IVRChaperone_003();
+    test_capi_thunks_IVRChaperoneSetup_005();
+    test_capi_thunks_IVRCompositor_022();
+    test_capi_thunks_IVRNotifications_002();
+    test_capi_thunks_IVROverlay_018();
+    test_capi_thunks_IVRRenderModels_005();
+    test_capi_thunks_IVRExtendedDisplay_001();
+    test_capi_thunks_IVRTrackedCamera_003();
+    test_capi_thunks_IVRScreenshots_001();
+    test_capi_thunks_IVRResources_001();
+    test_capi_thunks_IVRDriverManager_001();
+    test_capi_thunks_IVRInput_003();
+    test_capi_thunks_IVRIOBuffer_001();
+    test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVRSystem_017();
+    test_capi_thunks_IVROverlay_017();
+    test_capi_thunks_IVRCompositor_021();
+    test_capi_thunks_IVROverlay_016();
+    test_capi_thunks_IVRSystem_016();
+    test_capi_thunks_IVRCompositor_020();
+    test_capi_thunks_IVRClientCore_002();
+    test_capi_thunks_IVRSystem_015();
+    test_capi_thunks_IVROverlay_014();
+    test_capi_thunks_IVRCompositor_019();
+    test_capi_thunks_IVRSystem_014();
+    test_capi_thunks_IVRCompositor_018();
+    test_capi_thunks_IVROverlay_013();
+    test_capi_thunks_IVRSystem_012();
+    test_capi_thunks_IVRCompositor_016();
+    test_capi_thunks_IVRSettings_001();
+    test_capi_thunks_IVRApplications_005();
+    test_capi_thunks_IVRCompositor_015();
+    test_capi_thunks_IVROverlay_012();
+    test_capi_thunks_IVRTrackedCamera_002();
+    test_capi_thunks_IVRCompositor_014();
+    test_capi_thunks_IVROverlay_011();
+    test_capi_thunks_IVRCompositor_013();
+    test_capi_thunks_IVRSystem_011();
+    test_capi_thunks_IVRApplications_004();
+    test_capi_thunks_IVROverlay_010();
+    test_capi_thunks_IVRRenderModels_004();
+    test_capi_thunks_IVRCompositor_012();
+    test_capi_thunks_IVRApplications_003();
+    test_capi_thunks_IVRCompositor_011();
+    test_capi_thunks_IVRRenderModels_002();
+    test_capi_thunks_IVRSystem_010();
+    test_capi_thunks_IVRApplications_002();
+    test_capi_thunks_IVRChaperoneSetup_004();
+    test_capi_thunks_IVRCompositor_010();
+    test_capi_thunks_IVROverlay_008();
+    test_capi_thunks_IVRTrackedCamera_001();
+    test_capi_thunks_IVRCompositor_009();
+    test_capi_thunks_IVRSystem_009();
+    test_capi_thunks_IVROverlay_007();
+    test_capi_thunks_IVRSystem_006();
+    test_capi_thunks_IVRApplications_001();
+    test_capi_thunks_IVRChaperone_002();
+    test_capi_thunks_IVRCompositor_008();
+    test_capi_thunks_IVRNotifications_001();
+    test_capi_thunks_IVROverlay_005();
+    test_capi_thunks_IVRRenderModels_001();
+    test_capi_thunks_IVRSystem_005();
+    test_capi_thunks_IVRCompositor_007();
+    test_capi_thunks_IVROverlay_004();
+    test_capi_thunks_IVROverlay_003();
+    test_capi_thunks_IVROverlay_002();
+    test_capi_thunks_IVRSystem_004();
+    test_capi_thunks_IVRCompositor_006();
+    test_capi_thunks_IVROverlay_001();
+    test_capi_thunks_IVRSystem_003();
+    test_capi_thunks_IVRCompositor_005();
+    printf("All tests executed.\n");
+}