Skip to content
Snippets Groups Projects
graphics.c 137 KiB
Newer Older
{
  SrtGraphicsIssues issues;
  const gchar *name;
  const gchar *api_version;
  const gchar *driver_version;
  const gchar *vendor_id;
  const gchar *device_id;
  const gchar *messages;
  SrtVkPhysicalDeviceType type;
} GraphicsDeviceTest;

typedef struct
  const gchar *description;
  SrtWindowSystem window_system;
  SrtRenderingInterface rendering_interface;
  SrtGraphicsLibraryVendor library_vendor;
  SrtGraphicsIssues issues;
  SrtTestFlags test_flags;
  const gchar *multiarch_tuple;
  const gchar *renderer_string;
  const gchar *version_string;
  const gchar *messages;
  /* Arbitrary size, increase it if necessary */
  GraphicsDeviceTest devices[4];
  gboolean vendor_neutral;
} GraphicsTest;
static const GraphicsTest graphics_test[] =
{
  {
    .description = "good vdpau",
    .window_system = SRT_WINDOW_SYSTEM_X11,
    .rendering_interface = SRT_RENDERING_INTERFACE_VDPAU,
    .issues = SRT_GRAPHICS_ISSUES_NONE,
    .multiarch_tuple = "mock-good",
    .renderer_string = SRT_TEST_GOOD_VDPAU_RENDERER,
    .vendor_neutral = TRUE,
  },
  {
    .description = "bad vdpau",
    .window_system = SRT_WINDOW_SYSTEM_X11,
    .rendering_interface = SRT_RENDERING_INTERFACE_VDPAU,
    .issues = SRT_GRAPHICS_ISSUES_CANNOT_DRAW,
    .multiarch_tuple = "mock-bad",
    .messages = SRT_TEST_BAD_VDPAU_MESSAGES,
    .exit_status = 1,
    .vendor_neutral = TRUE,
  },
  {
    .description = "good gl",
    .window_system = SRT_WINDOW_SYSTEM_GLX,
    .rendering_interface = SRT_RENDERING_INTERFACE_GL,
    .issues = SRT_GRAPHICS_ISSUES_NONE,
    .multiarch_tuple = "mock-good",
    .renderer_string = SRT_TEST_GOOD_GRAPHICS_RENDERER,
    .version_string = SRT_TEST_GOOD_GRAPHICS_VERSION,
  },
  {
    .description = "no graphics stack",
    .window_system = SRT_WINDOW_SYSTEM_GLX,
    .rendering_interface = SRT_RENDERING_INTERFACE_GL,
    .issues = SRT_GRAPHICS_ISSUES_CANNOT_LOAD,
    .multiarch_tuple = "mock-bad",
    .messages = "warning: this warning should always be logged\n"
                "Waffle error: 0x2 WAFFLE_ERROR_UNKNOWN: XOpenDisplay failed\n"
                "info: you used LIBGL_DEBUG=verbose\n",
    /* We used "mock-bad" for the architecture so, when checking the library vendor,
     * we will not be able to call the helper `mock-bad-check-library`.
     * For this reason we expect %SRT_GRAPHICS_LIBRARY_VENDOR_UNKNOWN */
    .library_vendor = SRT_GRAPHICS_LIBRARY_VENDOR_UNKNOWN,
    .exit_status = 1,
  },
  {
    .description = "graphics timeout",
    .window_system = SRT_WINDOW_SYSTEM_GLX,
    .rendering_interface = SRT_RENDERING_INTERFACE_GL,
    .issues = (SRT_GRAPHICS_ISSUES_CANNOT_LOAD | SRT_GRAPHICS_ISSUES_TIMEOUT),
    .test_flags = SRT_TEST_FLAGS_TIME_OUT_SOONER,
    .multiarch_tuple = "mock-hanging",
    // Timeout has exit code 124
    .exit_status = 124,
  },
  {
    .description = "software rendering",
    .window_system = SRT_WINDOW_SYSTEM_GLX,
    .rendering_interface = SRT_RENDERING_INTERFACE_GL,
    .issues = SRT_GRAPHICS_ISSUES_SOFTWARE_RENDERING,
    .multiarch_tuple = "mock-software",
    .renderer_string = SRT_TEST_SOFTWARE_GRAPHICS_RENDERER,
    .version_string = SRT_TEST_SOFTWARE_GRAPHICS_VERSION,
    .messages = "warning: this warning should always be logged\n"
                "info: you used LIBGL_DEBUG=verbose\n",
  },
  {
    .description = "gl driver ok but check-gl fails",
    .window_system = SRT_WINDOW_SYSTEM_GLX,
    .rendering_interface = SRT_RENDERING_INTERFACE_GL,
    .issues = SRT_GRAPHICS_ISSUES_CANNOT_DRAW,
    .multiarch_tuple = "mock-mixed",
    .renderer_string = SRT_TEST_GOOD_GRAPHICS_RENDERER,
    .version_string = SRT_TEST_GOOD_GRAPHICS_VERSION,
    .messages = "warning: this warning should always be logged\n"
                "Waffle error: 0x2 WAFFLE_ERROR_UNKNOWN: XOpenDisplay failed\n"
                "info: you used LIBGL_DEBUG=verbose\n",
    .exit_status = 1,
  },
  {
    .description = "good vulkan",
    .window_system = SRT_WINDOW_SYSTEM_X11,
    .rendering_interface = SRT_RENDERING_INTERFACE_VULKAN,
    .issues = SRT_GRAPHICS_ISSUES_NONE,
    .multiarch_tuple = "mock-good",
    .renderer_string = SRT_TEST_GOOD_GRAPHICS_RENDERER,
    .version_string = SRT_TEST_GOOD_VULKAN_VERSION,
    .messages = SRT_TEST_GOOD_VULKAN_MESSAGES,
    .devices =
    {
      {
        .name = SRT_TEST_GOOD_GRAPHICS_RENDERER,
        .api_version = SRT_TEST_GOOD_GRAPHICS_API_VERSION,
        .driver_version = SRT_TEST_GOOD_GRAPHICS_DRIVER_VERSION,
        .vendor_id = SRT_TEST_GOOD_GRAPHICS_VENDOR_ID,
        .device_id = SRT_TEST_GOOD_GRAPHICS_DEVICE_ID,
        .type = SRT_VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
      },
      {
        .name = SRT_TEST_SOFTWARE_GRAPHICS_RENDERER,
        .api_version = SRT_TEST_SOFTWARE_GRAPHICS_API_VERSION,
        .driver_version = SRT_TEST_SOFTWARE_GRAPHICS_DRIVER_VERSION,
        .vendor_id = SRT_TEST_SOFTWARE_GRAPHICS_VENDOR_ID,
        .device_id = SRT_TEST_SOFTWARE_GRAPHICS_DEVICE_ID,
        .type = SRT_VK_PHYSICAL_DEVICE_TYPE_CPU,
        .issues = SRT_GRAPHICS_ISSUES_SOFTWARE_RENDERING,
      },
    },
    .vendor_neutral = TRUE,
  },
  {
    .description = "bad vulkan",
    .window_system = SRT_WINDOW_SYSTEM_X11,
    .rendering_interface = SRT_RENDERING_INTERFACE_VULKAN,
    .issues = SRT_GRAPHICS_ISSUES_CANNOT_LOAD | SRT_GRAPHICS_ISSUES_CANNOT_DRAW,
    .multiarch_tuple = "mock-bad",
    .messages = SRT_TEST_BAD_VULKAN_MESSAGES,
    .exit_status = 1,
    .vendor_neutral = TRUE,
  },

  {
    .description = "good vulkan driver but drawing test fails",
    .window_system = SRT_WINDOW_SYSTEM_X11,
    .rendering_interface = SRT_RENDERING_INTERFACE_VULKAN,
    .issues = SRT_GRAPHICS_ISSUES_CANNOT_DRAW,
    .multiarch_tuple = "mock-mixed",
    .renderer_string = SRT_TEST_GOOD_GRAPHICS_RENDERER,
    .version_string = SRT_TEST_GOOD_VULKAN_VERSION,
    .messages = SRT_TEST_GOOD_VULKAN_MESSAGES,
    .exit_status = 1,
    .devices =
    {
      {
        .name = SRT_TEST_GOOD_GRAPHICS_RENDERER,
        .api_version = SRT_TEST_GOOD_GRAPHICS_API_VERSION,
        .driver_version = SRT_TEST_GOOD_GRAPHICS_DRIVER_VERSION,
        .vendor_id = SRT_TEST_GOOD_GRAPHICS_VENDOR_ID,
        .device_id = SRT_TEST_GOOD_GRAPHICS_DEVICE_ID,
        .type = SRT_VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
        .messages = SRT_TEST_MIXED_VULKAN_MESSAGES_1,
        .issues = SRT_GRAPHICS_ISSUES_CANNOT_DRAW,
      },
      {
        .name = SRT_TEST_SOFTWARE_GRAPHICS_RENDERER,
        .api_version = SRT_TEST_SOFTWARE_GRAPHICS_API_VERSION,
        .driver_version = SRT_TEST_SOFTWARE_GRAPHICS_DRIVER_VERSION,
        .vendor_id = SRT_TEST_SOFTWARE_GRAPHICS_VENDOR_ID,
        .device_id = SRT_TEST_SOFTWARE_GRAPHICS_DEVICE_ID,
        .type = SRT_VK_PHYSICAL_DEVICE_TYPE_CPU,
        .messages = SRT_TEST_MIXED_VULKAN_MESSAGES_2,
        .issues = SRT_GRAPHICS_ISSUES_CANNOT_DRAW | SRT_GRAPHICS_ISSUES_SOFTWARE_RENDERING,
      },
    },
    .vendor_neutral = TRUE,
  },

  {
    .description = "good va-api",
    .window_system = SRT_WINDOW_SYSTEM_X11,
    .rendering_interface = SRT_RENDERING_INTERFACE_VAAPI,
    .issues = SRT_GRAPHICS_ISSUES_NONE,
    .multiarch_tuple = "mock-good",
    .renderer_string = SRT_TEST_GOOD_VAAPI_RENDERER,
    .vendor_neutral = TRUE,
  },

  {
    .description = "bad va-api",
    .window_system = SRT_WINDOW_SYSTEM_X11,
    .rendering_interface = SRT_RENDERING_INTERFACE_VAAPI,
    .issues = SRT_GRAPHICS_ISSUES_CANNOT_DRAW,
    .multiarch_tuple = "mock-bad",
    .messages = SRT_TEST_BAD_VAAPI_MESSAGES,
    .exit_status = 1,
    .vendor_neutral = TRUE,
  },
};

static void
test_check_graphics (Fixture *f,
                     gconstpointer context)
{
  g_test_message ("Entering %s", G_STRFUNC);

  for (gsize i = 0; i < G_N_ELEMENTS (graphics_test); i++)
    {
      const GraphicsTest *test = &graphics_test[i];
      g_autoptr(SrtGraphics) graphics = NULL;
      g_autoptr(SrtObjectList) devices = NULL;
      SrtGraphicsIssues issues;
      g_autofree gchar *tuple = NULL;
      g_autofree gchar *renderer = NULL;
      g_autofree gchar *version = NULL;
      g_autofree gchar *messages = NULL;
      int exit_status;
      int terminating_signal;
      gboolean vendor_neutral;
      SrtGraphicsLibraryVendor library_vendor;

      g_test_message ("%s", test->description);

      g_autoptr(SrtSystemInfo) info = srt_system_info_new (NULL);
      srt_system_info_set_helpers_path (info, f->builddir);
      srt_system_info_set_test_flags (info, test->test_flags);

      issues = srt_system_info_check_graphics (info,
                                               test->multiarch_tuple,
                                               test->window_system,
                                               test->rendering_interface,
                                               &graphics);
      g_assert_cmpint (issues, ==, test->issues);
      g_assert_cmpstr (srt_graphics_get_renderer_string (graphics), ==, test->renderer_string);
      g_assert_cmpstr (srt_graphics_get_version_string (graphics), ==, test->version_string);
      g_assert_cmpstr (srt_graphics_get_messages (graphics), ==, test->messages);
      g_assert_cmpint (srt_graphics_get_exit_status (graphics), ==, test->exit_status);
      g_assert_cmpint (srt_graphics_get_terminating_signal (graphics), ==, 0);

      devices = srt_graphics_get_devices (graphics);
      for (j = 0, iter = devices; iter != NULL; iter = iter->next, j++)
        {
          g_autofree gchar *name = NULL;
          g_autofree gchar *api_version = NULL;
          g_autofree gchar *driver_version = NULL;
          g_autofree gchar *vendor_id = NULL;
          g_autofree gchar *device_id = NULL;
          SrtVkPhysicalDeviceType type;

          g_assert_cmpstr (srt_graphics_device_get_name (iter->data), ==, test->devices[j].name);
          g_assert_cmpstr (srt_graphics_device_get_api_version (iter->data), ==,
                           test->devices[j].api_version);
          g_assert_cmpstr (srt_graphics_device_get_driver_version (iter->data), ==,
                           test->devices[j].driver_version);
          g_assert_cmpstr (srt_graphics_device_get_vendor_id (iter->data), ==,
                           test->devices[j].vendor_id);
          g_assert_cmpstr (srt_graphics_device_get_device_id (iter->data), ==,
                           test->devices[j].device_id);
          g_assert_cmpint (srt_graphics_device_get_device_type (iter->data), ==,
                           test->devices[j].type);
          g_assert_cmpstr (srt_graphics_device_get_messages (iter->data), ==,
                           test->devices[j].messages);
          g_assert_cmpint (srt_graphics_device_get_issues (iter->data), ==,
                           test->devices[j].issues);

          g_object_get (iter->data,
                        "name", &name,
                        "api-version", &api_version,
                        "driver-version", &driver_version,
                        "vendor-id", &vendor_id,
                        "device-id", &device_id,
                        "type", &type,
                        "issues", &issues,
                        NULL);
          g_assert_cmpstr (name, ==, test->devices[j].name);
          g_assert_cmpstr (api_version, ==, test->devices[j].api_version);
          g_assert_cmpstr (driver_version, ==, test->devices[j].driver_version);
          g_assert_cmpstr (vendor_id, ==, test->devices[j].vendor_id);
          g_assert_cmpstr (device_id, ==, test->devices[j].device_id);
          g_assert_cmpint (type, ==, test->devices[j].type);
          g_assert_cmpint (issues, ==, test->devices[j].issues);
        }

      vendor_neutral = srt_graphics_library_is_vendor_neutral (graphics, &library_vendor);
      g_assert_cmpint (library_vendor, ==, test->library_vendor);
      g_assert_cmpint (vendor_neutral, ==, test->vendor_neutral);

      g_object_get (graphics,
                    "multiarch-tuple", &tuple,
                    "issues", &issues,
                    "renderer-string", &renderer,
                    "version-string", &version,
                    "messages", &messages,
                    "exit-status", &exit_status,
                    "terminating-signal", &terminating_signal,
                    NULL);
      g_assert_cmpint (issues, ==, test->issues);
      g_assert_cmpstr (tuple, ==, test->multiarch_tuple);
      g_assert_cmpstr (renderer, ==, test->renderer_string);
      g_assert_cmpstr (version, ==, test->version_string);
      g_assert_cmpstr (messages, ==, test->messages);
      g_assert_cmpint (exit_status, ==, test->exit_status);
      g_assert_cmpint (terminating_signal, ==, 0);
    }
Ludovico de Nittis's avatar
Ludovico de Nittis committed
static gint
glx_icd_compare (SrtGlxIcd *a, SrtGlxIcd *b)
{
  return g_strcmp0 (srt_glx_icd_get_library_soname (a), srt_glx_icd_get_library_soname (b));
}

static void
test_glx_debian (Fixture *f,
                 gconstpointer context)
{
  g_autoptr(SrtSystemInfo) info = NULL;
  g_auto(GStrv) envp = NULL;
  g_autofree gchar *sysroot = NULL;
Ludovico de Nittis's avatar
Ludovico de Nittis committed
  GList *glx;
  const gchar *multiarch_tuples[] = {"i386-mock-debian", "x86_64-mock-debian", NULL};
  const gchar *glx_suffixes_i386[] = {"libGLX_mesa.so.0",
                                      "libGLX_nvidia.so.0",
                                      NULL};
  const gchar *glx_paths_i386[] = {"/lib/i386-linux-gnu/libGLX_mesa.so.0",
                                   "/lib/i386-linux-gnu/libGLX_nvidia.so.0",
                                   NULL};
  const gchar *glx_suffixes_x86_64[] = {"libGLX_mesa.so.0",
                                        NULL};
  const gchar *glx_paths_x86_64[] = {"/lib/x86_64-linux-gnu/libGLX_mesa.so.0",
                                     NULL};

  g_test_message ("Entering %s", G_STRFUNC);

  sysroot = g_build_filename (f->sysroots, "debian10", NULL);
Ludovico de Nittis's avatar
Ludovico de Nittis committed
  envp = g_get_environ ();
  envp = g_environ_setenv (envp, "SRT_TEST_SYSROOT", sysroot, TRUE);

  info = srt_system_info_new (NULL);
  srt_system_info_set_environ (info, envp);
  srt_system_info_set_sysroot (info, sysroot);
  srt_system_info_set_helpers_path (info, f->builddir);

Ludovico de Nittis's avatar
Ludovico de Nittis committed
  glx = srt_system_info_list_glx_icds (info, multiarch_tuples[0], SRT_DRIVER_FLAGS_NONE);
  /* The icds are not provided in a guaranteed order. Sort them before checking
   * with the expectations */
  glx = g_list_sort (glx, (GCompareFunc) glx_icd_compare);
  check_list_suffixes (glx, glx_suffixes_i386, SRT_GRAPHICS_GLX_MODULE);
  check_list_links (glx, glx_paths_i386, SRT_GRAPHICS_GLX_MODULE);
  g_list_free_full (glx, g_object_unref);

Ludovico de Nittis's avatar
Ludovico de Nittis committed
  glx = srt_system_info_list_glx_icds (info, multiarch_tuples[1], SRT_DRIVER_FLAGS_NONE);
  /* The icds are not provided in a guaranteed order. Sort them before checking
   * with the expectations */
  glx = g_list_sort (glx, (GCompareFunc) glx_icd_compare);
  check_list_suffixes (glx, glx_suffixes_x86_64, SRT_GRAPHICS_GLX_MODULE);
  check_list_links (glx, glx_paths_x86_64, SRT_GRAPHICS_GLX_MODULE);
  g_list_free_full (glx, g_object_unref);
}

static void
test_glx_container (Fixture *f,
                    gconstpointer context)
{
  g_autoptr(SrtSystemInfo) info = NULL;
  g_auto(GStrv) envp = NULL;
  g_autofree gchar *sysroot = NULL;
Ludovico de Nittis's avatar
Ludovico de Nittis committed
  GList *glx;
  const gchar *multiarch_tuples[] = {"i386-mock-container", "x86_64-mock-container", NULL};
  const gchar *glx_suffixes_i386[] = {"libGLX_nvidia.so.0",
                                      NULL};
  const gchar *glx_paths_i386[] = {"/lib/i386-linux-gnu/libGLX_nvidia.so.0",
                                   NULL};
  const gchar *glx_suffixes_x86_64[] = {"libGLX_custom.so.0",
                                        "libGLX_mesa.so.0",
                                        NULL};
  const gchar *glx_paths_x86_64[] = {"/lib/x86_64-linux-gnu/libGLX_custom.so.0",
                                     "/lib/x86_64-linux-gnu/libGLX_mesa.so.0",
                                     NULL};

  g_test_message ("Entering %s", G_STRFUNC);

  sysroot = g_build_filename (f->sysroots, "steamrt", NULL);
Ludovico de Nittis's avatar
Ludovico de Nittis committed
  envp = g_get_environ ();
  envp = g_environ_setenv (envp, "SRT_TEST_SYSROOT", sysroot, TRUE);

  info = srt_system_info_new (NULL);
  srt_system_info_set_environ (info, envp);
  srt_system_info_set_sysroot (info, sysroot);
  srt_system_info_set_helpers_path (info, f->builddir);

Ludovico de Nittis's avatar
Ludovico de Nittis committed
  glx = srt_system_info_list_glx_icds (info, multiarch_tuples[0], SRT_DRIVER_FLAGS_NONE);
  /* The icds are not provided in a guaranteed order. Sort them before checking
   * with the expectations */
  glx = g_list_sort (glx, (GCompareFunc) glx_icd_compare);
  check_list_suffixes (glx, glx_suffixes_i386, SRT_GRAPHICS_GLX_MODULE);
  check_list_links (glx, glx_paths_i386, SRT_GRAPHICS_GLX_MODULE);
  g_list_free_full (glx, g_object_unref);

Ludovico de Nittis's avatar
Ludovico de Nittis committed
  glx = srt_system_info_list_glx_icds (info, multiarch_tuples[1], SRT_DRIVER_FLAGS_NONE);
  /* The icds are not provided in a guaranteed order. Sort them before checking
   * with the expectations */
  glx = g_list_sort (glx, (GCompareFunc) glx_icd_compare);
  check_list_suffixes (glx, glx_suffixes_x86_64, SRT_GRAPHICS_GLX_MODULE);
  check_list_links (glx, glx_paths_x86_64, SRT_GRAPHICS_GLX_MODULE);
  g_list_free_full (glx, g_object_unref);
}

static const Config dir_config = { ICD_MODE_EXPLICIT_DIRS };
static const Config filename_config = { ICD_MODE_EXPLICIT_FILENAMES };
static const Config flatpak_config = { ICD_MODE_FLATPAK };
static const Config relative_config = { ICD_MODE_RELATIVE_FILENAMES };
static const Config xdg_config = { ICD_MODE_XDG_DIRS };

int
main (int argc,
      char **argv)
{
  argv0 = argv[0];
  _srt_tests_init (&argc, &argv, NULL);
  global_sysroots = _srt_global_setup_sysroots (argv0);
  g_test_add ("/graphics/object", Fixture, NULL,
              setup, test_object, teardown);
  g_test_add ("/graphics/normalize_window_system", Fixture, NULL,
              setup, test_normalize_window_system, teardown);
  g_test_add ("/graphics/sigusr", Fixture, NULL,
              setup, test_sigusr, teardown);
  g_test_add ("/graphics/icd/egl/basic", Fixture, NULL,
              setup, test_icd_egl, teardown);
  g_test_add ("/graphics/icd/egl/dirs", Fixture, &dir_config,
              setup, test_icd_egl, teardown);
  g_test_add ("/graphics/icd/egl/filenames", Fixture, &filename_config,
              setup, test_icd_egl, teardown);
  g_test_add ("/graphics/icd/egl/flatpak", Fixture, &flatpak_config,
              setup, test_icd_egl, teardown);
  g_test_add ("/graphics/icd/egl/relative", Fixture, &relative_config,
              setup, test_icd_egl, teardown);
  g_test_add ("/graphics/icd/egl/xdg", Fixture, &xdg_config,
              setup, test_icd_egl, teardown);
  g_test_add ("/graphics/icd/egl_external_platform/basic", Fixture, NULL,
              setup, test_egl_external_platform, teardown);
  g_test_add ("/graphics/icd/egl_external_platform/dirs", Fixture, &dir_config,
              setup, test_egl_external_platform, teardown);
  g_test_add ("/graphics/icd/egl_external_platform/filenames", Fixture, &filename_config,
              setup, test_egl_external_platform, teardown);
  g_test_add ("/graphics/icd/egl_external_platform/relative", Fixture, &relative_config,
              setup, test_egl_external_platform, teardown);
  g_test_add ("/graphics/icd/vulkan_exp/basic", Fixture, NULL,
              setup, test_icd_vulkan_explicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_exp/filenames", Fixture, &filename_config,
              setup, test_icd_vulkan_explicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_exp/flatpak", Fixture, &flatpak_config,
              setup, test_icd_vulkan_explicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_exp/relative", Fixture, &relative_config,
              setup, test_icd_vulkan_explicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_exp/xdg", Fixture, &xdg_config,
              setup, test_icd_vulkan_explicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_imp/basic", Fixture, NULL,
              setup, test_icd_vulkan_implicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_imp/filenames", Fixture, &filename_config,
              setup, test_icd_vulkan_implicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_imp/flatpak", Fixture, &flatpak_config,
              setup, test_icd_vulkan_implicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_imp/relative", Fixture, &relative_config,
              setup, test_icd_vulkan_implicit_multiarch, teardown);
  g_test_add ("/graphics/icd/vulkan_imp/xdg", Fixture, &xdg_config,
              setup, test_icd_vulkan_implicit_multiarch, teardown);
  g_test_add ("/graphics/layers/vulkan/xdg", Fixture, NULL,
              setup, test_layer_vulkan, teardown);

  g_test_add ("/graphics/dri/debian10", Fixture, NULL,
              setup, test_dri_debian10, teardown);
  g_test_add ("/graphics/dri/fedora", Fixture, NULL,
              setup, test_dri_fedora, teardown);
  g_test_add ("/graphics/dri/ubuntu16", Fixture, NULL,
              setup, test_dri_ubuntu16, teardown);
  g_test_add ("/graphics/dri/with_env", Fixture, NULL,
              setup, test_dri_with_env, teardown);
  g_test_add ("/graphics/dri/flatpak", Fixture, NULL,
              setup, test_dri_flatpak, teardown);

  g_test_add ("/graphics/vdpau/basic", Fixture, NULL,
              setup, test_vdpau, teardown);

  g_test_add ("/graphics/check", Fixture, NULL,
              setup, test_check_graphics, teardown);
Ludovico de Nittis's avatar
Ludovico de Nittis committed
  g_test_add ("/graphics/glx/debian", Fixture, NULL,
              setup, test_glx_debian, teardown);
  g_test_add ("/graphics/glx/container", Fixture, NULL,
              setup, test_glx_container, teardown);

  ret = g_test_run ();
  _srt_global_teardown_sysroots ();
  g_clear_pointer (&global_sysroots, g_free);
  return ret;