mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 21:06:09 +00:00
530 lines
20 KiB
Python
530 lines
20 KiB
Python
from pathlib import Path
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
|
|
|
|
ONCE = r"""
|
|
#define _GNU_SOURCE
|
|
#include <dlfcn.h>
|
|
#include <pthread.h>
|
|
#include <sys/syscall.h>
|
|
#include <unistd.h>
|
|
|
|
static pthread_once_t once = PTHREAD_ONCE_INIT;
|
|
static long (*next_syscall)(long, ...);
|
|
|
|
static void init(void) { next_syscall = (long (*)(long, ...))dlsym(RTLD_NEXT, "syscall"); }
|
|
|
|
ssize_t readlink(const char *path, char *buf, size_t size) {
|
|
pthread_once(&once, init);
|
|
return next_syscall(SYS_readlinkat, -100, path, buf, size);
|
|
}
|
|
|
|
__attribute__((constructor)) static void start(void) {
|
|
char link[4096];
|
|
readlink("/proc/self/exe", link, sizeof(link));
|
|
}
|
|
"""
|
|
|
|
FIRST = r"""
|
|
#define _GNU_SOURCE
|
|
#include <dlfcn.h>
|
|
#include <stddef.h>
|
|
|
|
int marker(void) { return 1; }
|
|
|
|
int next_marker(void) {
|
|
int (*next)(void) = (int (*)(void))dlsym(RTLD_NEXT, "marker");
|
|
return next != NULL ? next() : 0;
|
|
}
|
|
"""
|
|
|
|
SECOND = "int marker(void) { return 2; }\n"
|
|
|
|
CHAIN = r"""
|
|
#define _GNU_SOURCE
|
|
#include <dlfcn.h>
|
|
#include <stddef.h>
|
|
|
|
static int calls;
|
|
|
|
int chained(void) { return calls > 1; }
|
|
|
|
void *dlsym(void *handle, const char *name) {
|
|
static void *(*real)(void *, const char *);
|
|
if (real == NULL) real = (void *(*)(void *, const char *))dlvsym(RTLD_NEXT, "dlsym", "GLIBC_2.2.5");
|
|
if (real == NULL) real = (void *(*)(void *, const char *))dlvsym(RTLD_NEXT, "dlsym", "GLIBC_2.17");
|
|
if (real == NULL) real = (void *(*)(void *, const char *))dlvsym(RTLD_NEXT, "dlsym", "GLIBC_2.34");
|
|
calls++;
|
|
return real(handle, name);
|
|
}
|
|
"""
|
|
|
|
MARK = r"""
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
char *realpath(const char *path, char *resolved) {
|
|
(void)path;
|
|
if (resolved == NULL) return strdup("marked");
|
|
strcpy(resolved, "marked");
|
|
return resolved;
|
|
}
|
|
"""
|
|
|
|
UDEV = r"""
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
struct list { const char *name; struct list *next; };
|
|
struct enumerate { struct list head; struct list added; char name[16]; int fail; };
|
|
|
|
void *udev_enumerate_new(void *udev) {
|
|
static int count;
|
|
struct enumerate *enumerate = calloc(1, sizeof(*enumerate));
|
|
(void)udev;
|
|
snprintf(enumerate->name, sizeof(enumerate->name), "real%d", count++);
|
|
enumerate->head.name = enumerate->name;
|
|
enumerate->added.name = "added";
|
|
return enumerate;
|
|
}
|
|
void *udev_enumerate_unref(void *enumerate) { free(enumerate); return NULL; }
|
|
int udev_enumerate_add_match_subsystem(void *enumerate, const char *subsystem) {
|
|
if (strcmp(subsystem, "fail") == 0) ((struct enumerate *)enumerate)->fail = 1;
|
|
return 0;
|
|
}
|
|
int udev_enumerate_add_match_parent(void *enumerate, void *parent) {
|
|
if (parent == NULL) return -1;
|
|
((struct enumerate *)enumerate)->head.name = "parented";
|
|
return 0;
|
|
}
|
|
int udev_enumerate_add_syspath(void *enumerate, const char *syspath) {
|
|
(void)syspath;
|
|
((struct enumerate *)enumerate)->head.next = &((struct enumerate *)enumerate)->added;
|
|
return 0;
|
|
}
|
|
int udev_enumerate_scan_devices(void *enumerate) { return ((struct enumerate *)enumerate)->fail ? -1 : 0; }
|
|
void *udev_enumerate_get_list_entry(void *enumerate) { return &((struct enumerate *)enumerate)->head; }
|
|
void *udev_list_entry_get_next(void *entry) { return ((struct list *)entry)->next; }
|
|
void *udev_list_entry_get_by_name(void *entry, const char *name) {
|
|
return strcmp(((struct list *)entry)->name, name) == 0 ? entry : NULL;
|
|
}
|
|
const char *udev_list_entry_get_name(void *entry) { return ((struct list *)entry)->name; }
|
|
void *udev_device_new_from_syspath(void *udev, const char *syspath) { (void)udev; (void)syspath; return NULL; }
|
|
void *udev_device_new_from_subsystem_sysname(void *udev, const char *subsystem, const char *sysname) {
|
|
(void)udev; (void)subsystem; (void)sysname;
|
|
return NULL;
|
|
}
|
|
void *udev_device_unref(void *device) { (void)device; return NULL; }
|
|
void *udev_device_ref(void *device) { (void)device; return NULL; }
|
|
void *udev_device_get_parent(void *device) { (void)device; return NULL; }
|
|
void *udev_device_get_udev(void *device) { (void)device; return NULL; }
|
|
const char *udev_device_get_syspath(void *device) { (void)device; return "real"; }
|
|
const char *udev_device_get_sysnum(void *device) { (void)device; return "real"; }
|
|
"""
|
|
|
|
PROGRAM = r"""
|
|
#define _GNU_SOURCE
|
|
#include <dlfcn.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#define PAD "/sys/devices/virtual/input/droiddeck0"
|
|
#define PARENT0 "/sys/devices/droiddeck0/droiddeck-input0"
|
|
#define EVENT0 PARENT0 "/event0"
|
|
#define EVENT1 "/sys/devices/droiddeck1/droiddeck-input1/event1"
|
|
#define HANDLES 256
|
|
|
|
int next_marker(void);
|
|
|
|
static void *lib;
|
|
static void *(*new_device)(void *, const char *);
|
|
static void *(*new_sysname)(void *, const char *, const char *);
|
|
static void *(*ref)(void *);
|
|
static void *(*unref)(void *);
|
|
static void *(*get_parent)(void *);
|
|
static void *(*get_udev)(void *);
|
|
static const char *(*syspath)(void *);
|
|
static const char *(*sysname)(void *);
|
|
static const char *(*sysnum)(void *);
|
|
static const char *(*devnode)(void *);
|
|
static const char *(*property)(void *, const char *);
|
|
static void *(*properties)(void *);
|
|
static void *(*enumerate_new)(void *);
|
|
static int (*match)(void *, const char *);
|
|
static int (*match_parent)(void *, void *);
|
|
static int (*add_syspath)(void *, const char *);
|
|
static int (*scan)(void *);
|
|
static void *(*list)(void *);
|
|
static void *(*next)(void *);
|
|
static void *(*by_name)(void *, const char *);
|
|
static const char *(*name)(void *);
|
|
static const char *(*value)(void *);
|
|
|
|
static void *sym(const char *symbol) { return dlsym(lib, symbol); }
|
|
|
|
static const char *entry_name(void *entry) { return entry != NULL ? name(entry) : "none"; }
|
|
|
|
static void print_list(const char *label, void *entry) {
|
|
printf("%s", label);
|
|
for (; entry != NULL; entry = next(entry)) printf(" %s", name(entry));
|
|
printf("\n");
|
|
}
|
|
|
|
static void print_properties(const char *label, void *device) {
|
|
void *entry;
|
|
|
|
printf("%s", label);
|
|
for (entry = properties(device); entry != NULL; entry = next(entry)) printf(" %s=%s", name(entry), value(entry));
|
|
printf("\n");
|
|
}
|
|
|
|
static void *matched(void *udev, const char *subsystem) {
|
|
void *enumerate = enumerate_new(udev);
|
|
|
|
match(enumerate, subsystem);
|
|
return enumerate;
|
|
}
|
|
|
|
static void pad_file(const char *node, int present) {
|
|
char path[4096];
|
|
FILE *file;
|
|
|
|
snprintf(path, sizeof(path), "%s/%s", getenv("FAKE_EVDEV_DIR"), node);
|
|
if (!present) {
|
|
unlink(path);
|
|
} else if ((file = fopen(path, "w")) != NULL) {
|
|
fclose(file);
|
|
}
|
|
}
|
|
|
|
static void run_udev(void) {
|
|
int udev_a, udev_b, i, failures = 0;
|
|
void *device, *parent, *other, *entry, *held[HANDLES] = {0};
|
|
char resolved[4096];
|
|
const char *path;
|
|
|
|
printf("missing %d\n", sym("udev_no_such_symbol") == NULL);
|
|
printf("plain %d\n", dlsym(RTLD_DEFAULT, "printf") != NULL);
|
|
device = new_device(&udev_a, PAD);
|
|
printf("syspath %s sysnum %s devnode %s\n", syspath(device), sysnum(device), devnode(device));
|
|
parent = get_parent(device);
|
|
printf("nested %d\n", strncmp(syspath(device), syspath(parent), strlen(syspath(parent))) == 0 &&
|
|
syspath(device)[strlen(syspath(parent))] == '/');
|
|
other = new_device(&udev_a, EVENT0);
|
|
printf("canonical %s\n", other != NULL ? syspath(other) : "none");
|
|
if (other != NULL) unref(other);
|
|
printf("parent %s sysname %s stable %d\n", syspath(parent), sysname(parent), parent == get_parent(device));
|
|
print_properties("device properties", device);
|
|
print_properties("parent properties", parent);
|
|
entry = properties(device);
|
|
printf("joystick %s unknown %d\n", value(by_name(entry, "ID_INPUT_JOYSTICK")), by_name(entry, "NO_SUCH_KEY") == NULL);
|
|
ref(device);
|
|
unref(device);
|
|
printf("held %s\n", syspath(device));
|
|
ref(parent);
|
|
unref(device);
|
|
printf("retained %s\n", syspath(parent));
|
|
unref(parent);
|
|
for (i = 0; i < 1000; i++) {
|
|
device = new_device(&udev_a, PAD);
|
|
if (device == NULL || get_parent(device) == NULL || get_parent(device) != get_parent(device) ||
|
|
strcmp(syspath(device), EVENT0) != 0)
|
|
failures++;
|
|
if (device != NULL) unref(device);
|
|
}
|
|
printf("reuse failures %d\n", failures);
|
|
for (i = 0; i < HANDLES && (held[i] = new_device(&udev_a, PAD)) != NULL; i++) {
|
|
}
|
|
printf("full %d extra %d parent %d\n", i, new_device(&udev_a, PAD) == NULL, get_parent(held[0]) == NULL);
|
|
unref(held[1]);
|
|
parent = get_parent(held[0]);
|
|
printf("freed parent %s stable %d\n", parent != NULL ? syspath(parent) : "none", parent == get_parent(held[0]));
|
|
for (i = 0; i < HANDLES; i++)
|
|
if (i != 1 && held[i] != NULL) unref(held[i]);
|
|
path = realpath("/sys/class/input/droiddeck-input0", resolved);
|
|
printf("parent link %s\n", path != NULL ? path : "none");
|
|
path = realpath("/sys/class/input/input0", resolved);
|
|
printf("kernel link shadowed %d\n", path != NULL && strncmp(path, "/sys/devices/droiddeck", 22) == 0);
|
|
printf("kernel sysname shadowed %d\n", new_sysname(&udev_a, "input", "input0") != NULL);
|
|
other = new_sysname(&udev_a, "input", "droiddeck-input0");
|
|
printf("parent sysname %s\n", other != NULL ? syspath(other) : "none");
|
|
if (other != NULL) unref(other);
|
|
device = new_device(&udev_a, PAD);
|
|
other = new_device(&udev_b, PAD);
|
|
printf("contexts %d %d\n", get_udev(device) == (void *)&udev_a, get_udev(other) == (void *)&udev_b);
|
|
}
|
|
|
|
static void run_stable(void) {
|
|
int udev;
|
|
char copy[64];
|
|
void *device = new_device(&udev, PAD);
|
|
const char *before = devnode(device);
|
|
|
|
snprintf(copy, sizeof(copy), "%s", before);
|
|
pad_file("event0", 0);
|
|
printf("gone %d\n", new_device(&udev, PAD) == NULL);
|
|
printf("devnode %s same %d property %s\n", devnode(device), devnode(device) == before && strcmp(before, copy) == 0,
|
|
property(device, "DEVNAME"));
|
|
}
|
|
|
|
static void run_enumerate(void) {
|
|
int udev, i;
|
|
void *first, *entry, *found, *missing, *failed, *parented, *real_parent, *device, *parent, *other;
|
|
|
|
first = matched(&udev, "input");
|
|
scan(first);
|
|
entry = list(first);
|
|
print_list("scan", entry);
|
|
pad_file("event1", 1);
|
|
print_list("same scan", list(first));
|
|
entry = list(first);
|
|
found = by_name(entry, EVENT0);
|
|
missing = by_name(entry, EVENT1);
|
|
printf("by name %s missing %d\n", entry_name(found), missing == NULL);
|
|
for (i = 0; i < 20; i++) {
|
|
void *other = matched(&udev, "input");
|
|
scan(other);
|
|
list(other);
|
|
}
|
|
printf("kept tail %s\n", entry_name(next(entry)));
|
|
scan(first);
|
|
print_list("rescan", list(first));
|
|
printf("rescan by name %s\n", entry_name(by_name(list(first), EVENT1)));
|
|
add_syspath(first, "/sys/devices/added");
|
|
print_list("added", list(first));
|
|
failed = matched(&udev, "input");
|
|
match(failed, "fail");
|
|
printf("failed scan %d\n", scan(failed));
|
|
print_list("failed", list(failed));
|
|
device = new_device(&udev, PAD);
|
|
parent = get_parent(device);
|
|
parented = enumerate_new(&udev);
|
|
printf("synthetic parent %d\n", match_parent(parented, parent));
|
|
scan(parented);
|
|
print_list("parented", list(parented));
|
|
real_parent = enumerate_new(&udev);
|
|
printf("real parent %d\n", match_parent(real_parent, &udev));
|
|
scan(real_parent);
|
|
print_list("real parent list", list(real_parent));
|
|
other = matched(&udev, "input");
|
|
match_parent(other, &udev);
|
|
scan(other);
|
|
print_list("real parent suppressed", list(other));
|
|
other = matched(&udev, "input");
|
|
match_parent(other, parent);
|
|
match_parent(other, &udev);
|
|
scan(other);
|
|
print_list("real replaces synthetic", list(other));
|
|
other = matched(&udev, "input");
|
|
match_parent(other, &udev);
|
|
match_parent(other, parent);
|
|
scan(other);
|
|
print_list("synthetic replaces real", list(other));
|
|
other = matched(&udev, "input");
|
|
match_parent(other, parent);
|
|
printf("bad parent %d\n", match_parent(other, NULL));
|
|
scan(other);
|
|
print_list("bad parent kept", list(other));
|
|
other = enumerate_new(&udev);
|
|
match(other, "fail");
|
|
match_parent(other, parent);
|
|
printf("nothing added scan %d\n", scan(other));
|
|
}
|
|
|
|
static void run_probe(void) {
|
|
int udev;
|
|
|
|
printf("pad %d\n", new_device(&udev, PAD) != NULL);
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
char link[4096];
|
|
|
|
if (strcmp(argv[1], "once") == 0) {
|
|
printf("readlink %d\n", readlink("/proc/self/exe", link, sizeof(link)) > 0);
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[1], "next") == 0) {
|
|
int (*chained)(void) = (int (*)(void))dlsym(RTLD_DEFAULT, "chained");
|
|
printf("next %d\n", next_marker());
|
|
if (chained != NULL) printf("chained %d\n", chained());
|
|
return 0;
|
|
}
|
|
lib = dlopen(argv[2], RTLD_NOW | RTLD_LOCAL);
|
|
if (strcmp(argv[1], "realpath") == 0) {
|
|
printf("realpath %s\n", realpath("/no/such/inputudev/path", link));
|
|
return 0;
|
|
}
|
|
new_device = sym("udev_device_new_from_syspath");
|
|
new_sysname = sym("udev_device_new_from_subsystem_sysname");
|
|
ref = sym("udev_device_ref");
|
|
unref = sym("udev_device_unref");
|
|
get_parent = sym("udev_device_get_parent");
|
|
get_udev = sym("udev_device_get_udev");
|
|
syspath = sym("udev_device_get_syspath");
|
|
sysname = sym("udev_device_get_sysname");
|
|
sysnum = sym("udev_device_get_sysnum");
|
|
devnode = sym("udev_device_get_devnode");
|
|
property = sym("udev_device_get_property_value");
|
|
properties = sym("udev_device_get_properties_list_entry");
|
|
enumerate_new = sym("udev_enumerate_new");
|
|
match = sym("udev_enumerate_add_match_subsystem");
|
|
match_parent = sym("udev_enumerate_add_match_parent");
|
|
add_syspath = sym("udev_enumerate_add_syspath");
|
|
scan = sym("udev_enumerate_scan_devices");
|
|
list = sym("udev_enumerate_get_list_entry");
|
|
next = sym("udev_list_entry_get_next");
|
|
by_name = sym("udev_list_entry_get_by_name");
|
|
name = sym("udev_list_entry_get_name");
|
|
value = sym("udev_list_entry_get_value");
|
|
if (strcmp(argv[1], "probe") == 0) run_probe();
|
|
else if (strcmp(argv[1], "stable") == 0) run_stable();
|
|
else if (strcmp(argv[1], "enumerate") == 0) run_enumerate();
|
|
else run_udev();
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
"""
|
|
|
|
|
|
def compile_c(*args):
|
|
result = subprocess.run(["cc", *args], capture_output=True, text=True)
|
|
if result.returncode != 0:
|
|
raise AssertionError(f"cc {' '.join(args)} failed:\n{result.stderr}")
|
|
return result.stdout
|
|
|
|
|
|
@unittest.skipUnless(sys.platform == "linux" and shutil.which("cc"), "needs Linux and cc")
|
|
class InputUdevPreloadTest(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.dir = Path(tempfile.mkdtemp())
|
|
cls.addClassCleanup(shutil.rmtree, cls.dir, ignore_errors=True)
|
|
build = cls.dir / "build"
|
|
build.mkdir()
|
|
if "__GLIBC__" not in compile_c("-dM", "-E", "-x", "c", "-include", "limits.h", "/dev/null"):
|
|
raise unittest.SkipTest("needs a glibc toolchain")
|
|
sources = (("once.c", ONCE), ("first.c", FIRST), ("second.c", SECOND), ("chain.c", CHAIN), ("mark.c", MARK),
|
|
("udev.c", UDEV), ("program.c", PROGRAM))
|
|
for name, text in sources:
|
|
(build / name).write_text(text)
|
|
cls.lib = cls.dir / "libddsession.so"
|
|
compile_c("-shared", "-fPIC", "-O2", "-Wall", "-pthread", "-o", str(cls.lib),
|
|
*map(str, sorted(PRELOAD.glob("*.c"))), "-ldl")
|
|
for name in ("once", "first", "second", "chain", "mark"):
|
|
compile_c("-shared", "-fPIC", "-O0", "-pthread", "-o", str(cls.dir / f"lib{name}.so"),
|
|
str(build / f"{name}.c"), "-ldl")
|
|
cls.udev = cls.dir / "libudev.so.1"
|
|
compile_c("-shared", "-fPIC", "-O2", "-o", str(cls.udev), str(build / "udev.c"))
|
|
cls.program = cls.dir / "program"
|
|
compile_c("-O0", "-o", str(cls.program), str(build / "program.c"), str(cls.dir / "libfirst.so"), "-ldl")
|
|
cls.pads = cls.pad_dir("pads", "event0")
|
|
|
|
@classmethod
|
|
def pad_dir(cls, name, *nodes):
|
|
pads = cls.dir / name
|
|
pads.mkdir()
|
|
for node in nodes:
|
|
(pads / node).write_text("")
|
|
return pads
|
|
|
|
def run_program(self, mode, *preloads, pads=None, slots="0=/pad", program=None):
|
|
env = dict(os.environ, LD_PRELOAD=":".join(str(self.dir / name) for name in ("libddsession.so", *preloads)),
|
|
FAKE_EVDEV_MEMFD_PATHS=slots, FAKE_EVDEV_DIR=str(pads or self.pads))
|
|
env.pop("FAKE_EVDEV_UINPUT", None)
|
|
result = subprocess.run([str(program or self.program), mode, str(self.udev)], env=env, capture_output=True, text=True,
|
|
timeout=20)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
return result.stdout.splitlines()
|
|
|
|
def test_a_lookup_from_another_preloads_initialiser_does_not_reenter_it(self):
|
|
self.assertEqual(self.run_program("once", "libonce.so"), ["readlink 1"])
|
|
|
|
def test_the_real_lookup_still_sees_the_original_caller(self):
|
|
self.assertEqual(self.run_program("next", "libfirst.so", "libsecond.so"), ["next 2"])
|
|
|
|
def test_another_preloads_dlsym_stays_in_the_chain(self):
|
|
self.assertEqual(self.run_program("next", "libfirst.so", "libchain.so", "libsecond.so"), ["next 2", "chained 1"])
|
|
|
|
def test_non_udev_lookups_skip_the_opened_libudev(self):
|
|
self.assertEqual(self.run_program("realpath", "libmark.so"), ["realpath marked"])
|
|
|
|
def test_a_program_resolving_udev_through_dlsym_gets_the_pads(self):
|
|
parent = "/sys/devices/droiddeck0/droiddeck-input0"
|
|
pad = f"{parent}/event0"
|
|
self.assertEqual(self.run_program("udev"), [
|
|
"missing 1",
|
|
"plain 1",
|
|
f"syspath {pad} sysnum 0 devnode /dev/input/event0",
|
|
"nested 1",
|
|
f"canonical {pad}",
|
|
f"parent {parent} sysname droiddeck-input0 stable 1",
|
|
f"device properties DEVNAME=/dev/input/event0 DEVPATH={pad[4:]} ID_INPUT=1 ID_INPUT_JOYSTICK=1",
|
|
f"parent properties DEVPATH={parent[4:]} ID_INPUT=1 ID_INPUT_JOYSTICK=1",
|
|
"joystick 1 unknown 1",
|
|
f"held {pad}",
|
|
f"retained {parent}",
|
|
"reuse failures 0",
|
|
"full 256 extra 1 parent 1",
|
|
f"freed parent {parent} stable 1",
|
|
f"parent link {parent}",
|
|
"kernel link shadowed 0",
|
|
"kernel sysname shadowed 0",
|
|
f"parent sysname {parent}",
|
|
"contexts 1 1",
|
|
])
|
|
|
|
def test_a_handle_keeps_its_strings_after_the_pad_goes_away(self):
|
|
self.assertEqual(self.run_program("stable", pads=self.pad_dir("stable", "event0")), [
|
|
"gone 1",
|
|
"devnode /dev/input/event0 same 1 property /dev/input/event0",
|
|
])
|
|
|
|
def test_enumerations_keep_their_scan_and_their_state(self):
|
|
parent = "/sys/devices/droiddeck0/droiddeck-input0"
|
|
pad = f"{parent}/event0"
|
|
pad1 = "/sys/devices/droiddeck1/droiddeck-input1/event1"
|
|
self.assertEqual(self.run_program("enumerate", pads=self.pad_dir("enumerate", "event0"), slots="0=/pad;1=/pad"), [
|
|
f"scan {pad} real0",
|
|
f"same scan {pad} real0",
|
|
f"by name {pad} missing 1",
|
|
"kept tail real0",
|
|
f"rescan {pad} {pad1} real0",
|
|
f"rescan by name {pad1}",
|
|
f"added {pad} {pad1} real0 added",
|
|
"failed scan 0",
|
|
f"failed {pad} {pad1}",
|
|
"synthetic parent 0",
|
|
f"parented {parent} {pad}",
|
|
"real parent 0",
|
|
"real parent list parented",
|
|
"real parent suppressed parented",
|
|
"real replaces synthetic parented",
|
|
f"synthetic replaces real {parent} {pad}",
|
|
"bad parent -1",
|
|
f"bad parent kept {parent} {pad}",
|
|
"nothing added scan -1",
|
|
])
|
|
|
|
def test_only_the_steam_client_runtime_path_gets_the_real_libudev(self):
|
|
for path, pad in (("steamrt64/steam", 0), ("steamrtarm64/steam", 0), ("steamrt64/steam-probe", 1),
|
|
("xsteamrt64/steam", 1), ("steamrt64/xsteam", 1), ("steamrt/steam", 1)):
|
|
with self.subTest(path=path):
|
|
client = self.dir / "clients" / path
|
|
client.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy(self.program, client)
|
|
self.assertEqual(self.run_program("probe", program=client), [f"pad {pad}"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|