mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-20 21:35:59 +00:00
feat: add immersive Quest SteamVR to the standard app (#910)
This commit is contained in:
1 parent
d21466be6b
commit
2847910f22
73 files changed
+5916
-289
No files matched your search
@@ -335,5 +335,35 @@ class AgentTest(unittest.TestCase):
|
||||
self.assertIn(child.pid, agent.game_pids(424242))
|
||||
|
||||
|
||||
class VrFocusTest(unittest.TestCase):
|
||||
def test_scene_dashboard_and_external_focus_changes(self):
|
||||
focus = agent.VrSceneFocus()
|
||||
self.assertEqual(focus.order([9, 7], [7, 42], 42), [42, 9, 7])
|
||||
self.assertIsNone(focus.order([42, 9, 7], [7, 42], 42))
|
||||
self.assertEqual(focus.order([42, 9, 7], [7, 42], None), [9, 7])
|
||||
self.assertIsNone(focus.order([9, 7], [7], 42))
|
||||
self.assertEqual(focus.order([9, 7], [7, 42], 42), [42, 9, 7])
|
||||
# Do not overwrite a different focus order installed after our last write.
|
||||
self.assertIsNone(focus.order([123, 7], [7, 42], None))
|
||||
|
||||
def test_scene_requires_live_server_and_game_environment(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
state = root / 'scene.json'
|
||||
for pid in (100, 200):
|
||||
(root / str(pid)).mkdir()
|
||||
(root / '100/comm').write_text('vrserver\n')
|
||||
(root / '200/environ').write_bytes(b'SteamAppId=42\0Other=value\0')
|
||||
state.write_text(json.dumps(dict(serverPid=100, scenePid=200, dashboard=False)))
|
||||
self.assertEqual(agent.vr_scene_app(state, root), 42)
|
||||
state.write_text(json.dumps(dict(serverPid=100, scenePid=200, dashboard=True)))
|
||||
self.assertIsNone(agent.vr_scene_app(state, root))
|
||||
state.write_text(json.dumps(dict(serverPid=100, scenePid=200, dashboard=False)))
|
||||
(root / '100/comm').write_text('other\n')
|
||||
self.assertIsNone(agent.vr_scene_app(state, root))
|
||||
(root / '100/comm').unlink()
|
||||
self.assertIsNone(agent.vr_scene_app(state, root))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,119 @@
|
||||
import importlib.machinery
|
||||
import importlib.util
|
||||
import json
|
||||
import gzip
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
import zlib
|
||||
|
||||
TOOLS = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(TOOLS))
|
||||
loader = importlib.machinery.SourceFileLoader('ctl_xr', str(TOOLS / 'droiddeckctl'))
|
||||
spec = importlib.util.spec_from_loader(loader.name, loader)
|
||||
ctl = importlib.util.module_from_spec(spec)
|
||||
loader.exec_module(ctl)
|
||||
|
||||
|
||||
class XrCaptureTest(unittest.TestCase):
|
||||
def test_png_keeps_rgb_rows_and_dimensions(self):
|
||||
pixels = bytes([255, 0, 0, 0, 255, 0, 0, 0, 255, 255, 255, 255])
|
||||
png = ctl.xr_ppm_to_png(b'P6\n2 2\n255\n' + pixels)
|
||||
self.assertEqual(png[:8], b'\x89PNG\r\n\x1a\n')
|
||||
self.assertEqual(struct.unpack('>II', png[16:24]), (2, 2))
|
||||
position = png.index(b'IDAT')
|
||||
size = struct.unpack('>I', png[position - 4:position])[0]
|
||||
self.assertEqual(zlib.decompress(png[position + 4:position + 4 + size]),
|
||||
b'\0' + pixels[:6] + b'\0' + pixels[6:])
|
||||
|
||||
def test_incomplete_or_invalid_images_are_rejected(self):
|
||||
for data in (b'P6\n2 2\n255\nabc', b'P6\n0 1\n255\n', b'P6\n999999 1\n255\n', b'junk'):
|
||||
with self.subTest(data=data), self.assertRaises(ctl.ControlError):
|
||||
ctl.xr_ppm_to_png(data)
|
||||
|
||||
def test_linear_source_and_display_eye_have_distinct_png_transfer_tags(self):
|
||||
image = b'P6\n1 1\n255\n\x37\x37\x37'
|
||||
self.assertIn(b'gAMA' + struct.pack('>I', 100000), ctl.xr_ppm_to_png(image, linear=True))
|
||||
self.assertIn(b'sRGB\0', ctl.xr_ppm_to_png(image))
|
||||
|
||||
def capture(self, root, failed=False, replaced=False, no_response=False, source=False, truncated=False):
|
||||
calls = []
|
||||
token = None
|
||||
reads = 0
|
||||
def adb(_adb, _serial, *args, **kwargs):
|
||||
nonlocal token, reads
|
||||
calls.append(args)
|
||||
stdout = b''
|
||||
if args[0] == 'push':
|
||||
token = Path(args[1]).read_text()
|
||||
if args[:2] == ('shell', 'cat'):
|
||||
reads += 1
|
||||
stdout = json.dumps({'id': ('old' if reads == 1 or no_response or (replaced and reads > 2) else token),
|
||||
'ok': not failed, 'validLayer': not failed, 'sourceImage': source}).encode()
|
||||
if args[0] == 'exec-out':
|
||||
stdout = gzip.compress(b'P6\n1 1\n255\n\x12\x34\x56')
|
||||
if truncated:
|
||||
stdout = stdout[:-5]
|
||||
return subprocess.CompletedProcess(args, 0, stdout, b'')
|
||||
with patch.object(ctl, 'run_adb', side_effect=adb), patch.object(ctl.time, 'sleep'):
|
||||
result = ctl.xr_capture('adb', 'quest', root, 0.01 if no_response else 2)
|
||||
return result, calls
|
||||
|
||||
def test_stale_response_is_ignored_and_matching_pair_is_published(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory) / 'capture'
|
||||
result, calls = self.capture(root)
|
||||
self.assertTrue(result['ok'])
|
||||
self.assertEqual((root / 'left.png').read_bytes(), (root / 'right.png').read_bytes())
|
||||
self.assertEqual(len([c for c in calls if c[:2] == ('shell', 'cat')]), 3)
|
||||
self.assertTrue((root / 'capture.json').is_file())
|
||||
|
||||
def test_invalid_layer_replaced_capture_and_timeout_publish_no_images(self):
|
||||
for flags in ({'failed': True}, {'replaced': True}, {'no_response': True}, {'truncated': True}):
|
||||
with self.subTest(flags=flags), tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory) / 'capture'
|
||||
with self.assertRaises(ctl.ControlError):
|
||||
self.capture(root, **flags)
|
||||
self.assertFalse(root.exists())
|
||||
|
||||
def test_source_capture_is_pulled_when_supported_by_the_headset(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory) / 'capture'
|
||||
result, calls = self.capture(root, source=True)
|
||||
self.assertEqual(result['source'], str((root / 'source.png').resolve()))
|
||||
self.assertEqual(len([c for c in calls if c[0] == 'exec-out']), 3)
|
||||
|
||||
def test_output_creation_and_write_failures_are_file_errors(self):
|
||||
for operation in ('mkdir', 'write_bytes'):
|
||||
with self.subTest(operation=operation), tempfile.TemporaryDirectory() as directory:
|
||||
with patch.object(Path, operation, side_effect=PermissionError('output denied')):
|
||||
with self.assertRaises(ctl.ControlError) as caught:
|
||||
self.capture(Path(directory) / 'capture')
|
||||
self.assertEqual(caught.exception.code, 'FILE_IO')
|
||||
self.assertEqual(ctl.exit_code(caught.exception), 6)
|
||||
|
||||
def test_stalled_metadata_read_uses_capture_deadline_and_reports_timeout(self):
|
||||
calls = []
|
||||
def adb(_adb, _serial, *args, **kwargs):
|
||||
calls.append((args, kwargs))
|
||||
if args[:2] == ('shell', 'cat'):
|
||||
self.assertGreater(kwargs['timeout'], 0)
|
||||
self.assertLessEqual(kwargs['timeout'], 0.1)
|
||||
try:
|
||||
raise subprocess.TimeoutExpired('adb', kwargs['timeout'])
|
||||
except subprocess.TimeoutExpired as cause:
|
||||
raise ctl.ControlError('metadata stalled', 'ADB_FAILED') from cause
|
||||
return subprocess.CompletedProcess(args, 0, b'', b'')
|
||||
with tempfile.TemporaryDirectory() as directory, patch.object(ctl, 'run_adb', side_effect=adb):
|
||||
with self.assertRaises(ctl.ControlError) as caught:
|
||||
ctl.xr_capture('adb', 'quest', Path(directory) / 'capture', 0.1)
|
||||
self.assertEqual(caught.exception.code, 'TIMEOUT')
|
||||
self.assertTrue(any(args[:3] == ('shell', 'rm', '-f') for args, _ in calls))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,85 @@
|
||||
import sys
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||||
from test_quest_xr import collect_device_metrics, summarize_samples, validate_samples
|
||||
import subprocess
|
||||
|
||||
|
||||
class QuestXrValidationTest(unittest.TestCase):
|
||||
def samples(self, source='frames'):
|
||||
return [{'rendered': count, 'sessionState': 5, 'headFlags': 15, 'source': source,
|
||||
'controllersActive': [False, False], 'guestFrames': count,
|
||||
'uploadedFrames': count, 'sourceFrameId': count + 1, 'steamvrState': 4}
|
||||
for count in (0, 144)]
|
||||
|
||||
def test_requires_owned_frame_projection(self):
|
||||
self.assertIsNone(validate_samples(self.samples()))
|
||||
self.assertEqual('Wrong projection source', validate_samples(self.samples('surface')))
|
||||
|
||||
def test_position_must_be_tracked_not_merely_valid(self):
|
||||
samples = self.samples()
|
||||
for sample in samples:
|
||||
sample['headFlags'] = 7
|
||||
self.assertIn('tracked 6DoF', validate_samples(samples))
|
||||
|
||||
def test_optional_controllers_cannot_be_claimed_as_tested(self):
|
||||
self.assertIn('controllers', validate_samples(self.samples(), require_controllers=True))
|
||||
|
||||
def test_one_early_tracked_sample_cannot_hide_final_tracking_loss(self):
|
||||
samples = self.samples()
|
||||
samples[-1]['headFlags'] = 7
|
||||
self.assertIn('final sample', validate_samples(samples))
|
||||
samples[-1]['headFlags'] = 15
|
||||
samples[-1]['sessionState'] = 4
|
||||
self.assertIn('final sample', validate_samples(samples))
|
||||
|
||||
def test_measured_rates_are_separate_from_runtime_refresh(self):
|
||||
samples = self.samples('frames')
|
||||
samples[0]['_hostMonotonicSeconds'] = 10
|
||||
samples[-1]['_hostMonotonicSeconds'] = 12
|
||||
samples[-1]['periodNs'] = 8333333
|
||||
summary = summarize_samples(samples)
|
||||
self.assertEqual(summary['observedSeconds'], 2)
|
||||
self.assertEqual(summary['ratesHz']['uploadedFrames'], 72)
|
||||
self.assertAlmostEqual(summary['runtimeRefreshHz'], 120, places=3)
|
||||
self.assertEqual(summary['focusedTrackedFraction'], 1)
|
||||
samples[-1]['uploadedFrames'] = -1
|
||||
self.assertIsNone(summarize_samples(samples)['ratesHz']['uploadedFrames'])
|
||||
self.assertIsNone(summarize_samples(self.samples())['observedSeconds'])
|
||||
self.assertIsNone(summarize_samples([])['focusedTrackedFraction'])
|
||||
|
||||
def test_metrics_failures_stay_unavailable_without_privileged_fallback(self):
|
||||
commands = []
|
||||
def adb(*command):
|
||||
commands.append(command)
|
||||
if command[-1] == 'battery':
|
||||
return 'temperature: 310'
|
||||
raise subprocess.CalledProcessError(1, command, stderr='Permission denied')
|
||||
metrics = collect_device_metrics(adb, 'com.droiddeck.launcher')
|
||||
self.assertEqual(len(commands), 3)
|
||||
self.assertTrue(metrics['battery']['available'])
|
||||
self.assertFalse(metrics['thermal']['available'])
|
||||
self.assertFalse(metrics['memory']['available'])
|
||||
|
||||
def test_steamvr_requires_owned_images_and_source_frame_ids(self):
|
||||
samples = self.samples('frames')
|
||||
self.assertIsNone(validate_samples(samples))
|
||||
samples[-1]['uploadedFrames'] = 0
|
||||
self.assertIn('owned SteamVR images', validate_samples(samples))
|
||||
samples[-1]['uploadedFrames'] = 144
|
||||
samples[-1]['sourceFrameId'] = samples[0]['sourceFrameId']
|
||||
self.assertIn('frame IDs', validate_samples(samples))
|
||||
|
||||
def test_running_process_alone_is_not_success(self):
|
||||
samples = self.samples('frames')
|
||||
samples[-1]['rendered'] = 0
|
||||
self.assertIn('stereo frames', validate_samples(samples))
|
||||
samples[-1]['rendered'] = 144
|
||||
samples[-1]['steamvrState'] = 3
|
||||
self.assertIn('RUNNING', validate_samples(samples))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -37,3 +37,9 @@ class SessionAssetsTest(unittest.TestCase):
|
||||
with ZipFile(self.apk, 'w') as package:
|
||||
package.writestr(self.name, self.helper.read_bytes())
|
||||
self.assertEqual([], assets.check(self.apk, self.overlay))
|
||||
|
||||
def test_bundled_helper_must_also_be_extracted(self):
|
||||
self.assertEqual(['not extracted at session start: usr/local/bin/droiddeck-login1'],
|
||||
assets.check_extraction(self.overlay, ''))
|
||||
mapping = '"usr/local/bin/droiddeck-login1" to "usr/local/bin/droiddeck-login1"'
|
||||
self.assertEqual([], assets.check_extraction(self.overlay, mapping))
|
||||
@@ -0,0 +1,65 @@
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import socket
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
SOURCE = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-steamvr-game'
|
||||
|
||||
|
||||
class SteamVrGameTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
temporary = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(temporary.cleanup)
|
||||
self.root = Path(temporary.name)
|
||||
self.helper = self.root / 'helper'
|
||||
self.assertIn('/run/droiddeck/droiddeck-xr-frames', SOURCE.read_text())
|
||||
self.helper.write_text(SOURCE.read_text().replace('/run/droiddeck/droiddeck-xr-frames',
|
||||
str(self.root / 'droiddeck-xr-frames')), encoding='utf-8')
|
||||
self.command('pgrep', '#!/bin/sh\nexit 0\n')
|
||||
self.command('gamescope', '#!/usr/bin/env python3\nimport json, os, sys\n'
|
||||
'print(json.dumps(dict(argv=sys.argv[1:], modifiers=os.getenv("gamescope_vr_use_modifiers"), '
|
||||
'layers=os.getenv("VK_INSTANCE_LAYERS"))))\n')
|
||||
self.env = {key: value for key, value in os.environ.items()
|
||||
if not key.startswith(('gamescope_vr_', 'VK_'))}
|
||||
self.env.update(PATH=str(self.root) + os.pathsep + os.environ['PATH'],
|
||||
XDG_RUNTIME_DIR=str(self.root))
|
||||
|
||||
def command(self, name, text):
|
||||
path = self.root / name
|
||||
path.write_text(text, encoding='utf-8')
|
||||
path.chmod(0o755)
|
||||
|
||||
def run_game(self, *args):
|
||||
return subprocess.run(['sh', str(self.helper), *args], env=self.env,
|
||||
capture_output=True, text=True, timeout=5)
|
||||
|
||||
def test_native_backend_preserves_command_arguments_and_nonquest_defaults(self):
|
||||
result = self.run_game('game with spaces', 'a b', '$literal')
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
data = json.loads(result.stdout)
|
||||
self.assertEqual(data['argv'][:2], ['--backend', 'openvr'])
|
||||
self.assertEqual(data['argv'][-4:], ['--', 'game with spaces', 'a b', '$literal'])
|
||||
self.assertIsNone(data['modifiers'])
|
||||
self.assertEqual(data['layers'], 'VK_LAYER_DROIDDECK_vr')
|
||||
|
||||
def test_quest_selects_vulkan_sharing_and_preserves_explicit_override(self):
|
||||
with socket.socket(socket.AF_UNIX) as receiver:
|
||||
receiver.bind(str(self.root / 'droiddeck-xr-frames'))
|
||||
self.assertEqual(json.loads(self.run_game('game').stdout)['modifiers'], 'false')
|
||||
self.env['gamescope_vr_use_modifiers'] = 'true'
|
||||
self.assertEqual(json.loads(self.run_game('game').stdout)['modifiers'], 'true')
|
||||
|
||||
def test_missing_runtime_and_missing_command_fail_clearly(self):
|
||||
self.assertEqual(self.run_game().returncode, 2)
|
||||
self.command('pgrep', '#!/bin/sh\nexit 1\n')
|
||||
result = self.run_game('game')
|
||||
self.assertEqual(result.returncode, 1)
|
||||
self.assertIn('Start SteamVR', result.stderr)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,204 @@
|
||||
import os
|
||||
import json
|
||||
import shutil
|
||||
import socket
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
SOURCE = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-steamvr'
|
||||
|
||||
|
||||
class SteamVrHelperTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temporary = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.temporary.cleanup)
|
||||
self.root = Path(self.temporary.name)
|
||||
self.home = self.root / 'home'
|
||||
self.runtime = self.root / 'runtime'
|
||||
self.commands = self.root / 'commands'
|
||||
self.driver = self.root / 'driver/droiddeck/bin/linuxarm64'
|
||||
self.steamvr = self.root / 'steamvr'
|
||||
for directory in (self.commands, self.driver, self.steamvr / 'bin/linuxarm64'):
|
||||
directory.mkdir(parents=True)
|
||||
self.helper = self.root / 'droiddeck-steamvr'
|
||||
self.assertIn('/run/droiddeck/droiddeck-xr-frames', SOURCE.read_text())
|
||||
self.helper.write_text(SOURCE.read_text().replace('/run/droiddeck/droiddeck-xr-frames',
|
||||
str(self.runtime / 'droiddeck-xr-frames')), encoding='utf-8')
|
||||
self.executable(self.commands / 'pgrep', 'exit 1')
|
||||
self.executable(self.commands / 'sleep', 'exit 0')
|
||||
self.executable(self.commands / 'xset', 'exit 0')
|
||||
self.executable(self.commands / 'setsid', 'exec "$@"')
|
||||
self.executable(self.driver / 'xr-display-mode', 'echo 3360x1760@120')
|
||||
self.executable(self.steamvr / 'bin/linuxarm64/vrstartup',
|
||||
'echo "display=${DROIDDECK_VR_DISPLAY_MODE:-unset}"')
|
||||
(self.driver / 'driver_droiddeck.so').touch()
|
||||
self.environment = dict(os.environ)
|
||||
self.environment.pop('DROIDDECK_VR_DISPLAY_MODE', None)
|
||||
self.environment.pop('DROIDDECK_VR_PRESENT', None)
|
||||
self.environment.pop('DROIDDECK_VR_PRODUCER_LEASE', None)
|
||||
self.environment.update(HOME=str(self.home), XDG_RUNTIME_DIR=str(self.runtime),
|
||||
STEAMVR=str(self.steamvr), DROIDDECK_VR_DIR=str(self.root / 'driver'),
|
||||
DROIDDECK_VR_SETTINGS_HELPER=str(SOURCE.with_name('droiddeck-steamvr-settings')),
|
||||
PATH=str(self.commands) + os.pathsep + os.environ['PATH'])
|
||||
|
||||
def executable(self, destination, body):
|
||||
destination.write_text('#!/bin/sh\n' + body + '\n', encoding='utf-8')
|
||||
destination.chmod(0o755)
|
||||
|
||||
def start(self):
|
||||
result = subprocess.run(['sh', str(self.helper), 'start'], env=self.environment,
|
||||
capture_output=True, text=True, timeout=5)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
log = self.home / '.local/share/Steam/logs/droiddeck-vrstartup.log'
|
||||
deadline = time.monotonic() + 2
|
||||
while time.monotonic() < deadline:
|
||||
if log.is_file() and 'display=' in log.read_text():
|
||||
return log
|
||||
time.sleep(0.01)
|
||||
self.fail('Startup log did not arrive')
|
||||
|
||||
def test_fresh_runtime_mode_is_selected_and_log_survives_runtime_cleanup(self):
|
||||
log = self.start()
|
||||
self.assertEqual((self.runtime / 'droiddeck-steamvr').stat().st_mode & 0o777, 0o700)
|
||||
self.assertEqual(log.read_text().strip(), 'display=3360x1760@120')
|
||||
self.assertEqual((self.runtime / 'droiddeck-steamvr/vrstartup.log').resolve(), log)
|
||||
shutil.rmtree(self.runtime)
|
||||
self.assertTrue(log.is_file())
|
||||
|
||||
def test_explicit_display_override_is_preserved(self):
|
||||
self.environment['DROIDDECK_VR_DISPLAY_MODE'] = '1920x1080@90'
|
||||
self.assertEqual(self.start().read_text().strip(), 'display=1920x1080@90')
|
||||
|
||||
def test_stale_or_missing_tracking_keeps_the_default(self):
|
||||
self.executable(self.driver / 'xr-display-mode', 'exit 1')
|
||||
self.assertEqual(self.start().read_text().strip(), 'display=unset')
|
||||
|
||||
def test_older_runtime_without_the_reader_still_starts(self):
|
||||
(self.driver / 'xr-display-mode').unlink()
|
||||
self.assertEqual(self.start().read_text().strip(), 'display=unset')
|
||||
|
||||
def lease_log(self):
|
||||
self.executable(self.steamvr / 'bin/linuxarm64/vrstartup',
|
||||
'printf "display=%s present=%s lease=%s\\n" "${DROIDDECK_VR_DISPLAY_MODE:-unset}" '
|
||||
'"${DROIDDECK_VR_PRESENT:-unset}" "${DROIDDECK_VR_PRODUCER_LEASE:-unset}"')
|
||||
return self.start().read_text().strip()
|
||||
|
||||
def test_quest_receiver_uses_normal_compositor_and_excludes_unsupported_frame_backend(self):
|
||||
self.runtime.mkdir()
|
||||
cvp = self.steamvr / 'drivers/cv/bin/linuxarm64/libArcturusPerception.so'
|
||||
cvp.parent.mkdir(parents=True)
|
||||
cvp.write_bytes(b'frame-only backend')
|
||||
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as receiver:
|
||||
receiver.bind(str(self.runtime / 'droiddeck-xr-frames'))
|
||||
self.assertIn('present=questwsi lease=unset', self.lease_log())
|
||||
settings = json.loads((self.home / '.local/share/Steam/config/steamvr.vrsettings').read_text())
|
||||
self.assertEqual(settings['steamvr'], {'enableLinuxVulkanAsync': True, 'motionSmoothing': False})
|
||||
self.assertFalse(cvp.exists())
|
||||
self.assertEqual(Path(str(cvp) + '.droiddeck-disabled').read_bytes(), b'frame-only backend')
|
||||
|
||||
def test_quest_settings_preserve_other_preferences_and_start_is_idempotent(self):
|
||||
self.environment['DROIDDECK_VR_PRESENT'] = 'questwsi'
|
||||
path = self.home / '.local/share/Steam/config/steamvr.vrsettings'
|
||||
path.parent.mkdir(parents=True)
|
||||
path.write_text(json.dumps({'steamvr': {'somePreference': 42}, 'dashboard': {'somePreference': True}}))
|
||||
self.start()
|
||||
self.start()
|
||||
settings = json.loads(path.read_text())
|
||||
self.assertEqual(settings['steamvr']['somePreference'], 42)
|
||||
self.assertEqual(settings['dashboard'], {'somePreference': True})
|
||||
|
||||
def test_quest_refuses_to_overwrite_malformed_settings(self):
|
||||
self.environment['DROIDDECK_VR_PRESENT'] = 'questwsi'
|
||||
path = self.home / '.local/share/Steam/config/steamvr.vrsettings'
|
||||
path.parent.mkdir(parents=True)
|
||||
path.write_text('invalid json')
|
||||
result = subprocess.run(['sh', str(self.helper), 'start'], env=self.environment,
|
||||
capture_output=True, text=True, timeout=5)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(path.read_text(), 'invalid json')
|
||||
|
||||
def test_quest_stop_restores_only_overridden_preferences(self):
|
||||
self.environment['DROIDDECK_VR_PRESENT'] = 'questwsi'
|
||||
path = self.home / '.local/share/Steam/config/steamvr.vrsettings'
|
||||
path.parent.mkdir(parents=True)
|
||||
path.write_text(json.dumps({'steamvr': {'motionSmoothing': True, 'somePreference': 42}}))
|
||||
self.start()
|
||||
settings = json.loads(path.read_text())
|
||||
settings['dashboard'] = {'changedDuringSession': True}
|
||||
path.write_text(json.dumps(settings))
|
||||
subprocess.run(['sh', str(self.helper), 'stop'], env=self.environment, check=True)
|
||||
self.assertEqual(json.loads(path.read_text()), {'steamvr': {'motionSmoothing': True, 'somePreference': 42},
|
||||
'dashboard': {'changedDuringSession': True}})
|
||||
|
||||
def test_invalid_backup_preserves_preferences_until_repaired(self):
|
||||
settings = self.root / 'steamvr.vrsettings'
|
||||
backup = self.root / 'quest-backup.json'
|
||||
helper = SOURCE.with_name('droiddeck-steamvr-settings')
|
||||
original = {'steamvr': {'motionSmoothing': True}, 'dashboard': {'unchanged': 42}}
|
||||
settings.write_text(json.dumps(original))
|
||||
subprocess.run([sys.executable, str(helper), 'apply', str(settings), str(backup)], check=True)
|
||||
valid_backup = backup.read_bytes()
|
||||
applied = settings.read_bytes()
|
||||
invalid = ['truncated {', '{}', '{"section": true, "values": []}',
|
||||
'{"section": false, "values": {"motionSmoothing": [false]}}']
|
||||
for content in invalid:
|
||||
for operation in ('apply', 'restore'):
|
||||
with self.subTest(content=content, operation=operation):
|
||||
backup.write_text(content)
|
||||
result = subprocess.run([sys.executable, str(helper), operation, str(settings), str(backup)],
|
||||
capture_output=True, text=True)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn('repair the saved section/values and retry restore', result.stderr)
|
||||
self.assertEqual(backup.read_text(), content)
|
||||
self.assertEqual(settings.read_bytes(), applied)
|
||||
backup.write_bytes(valid_backup)
|
||||
subprocess.run([sys.executable, str(helper), 'restore', str(settings), str(backup)], check=True)
|
||||
self.assertEqual(json.loads(settings.read_text()), original)
|
||||
self.assertFalse(backup.exists())
|
||||
|
||||
def test_quest_update_preserves_previous_cvp_backup(self):
|
||||
self.environment['DROIDDECK_VR_PRESENT'] = 'questwsi'
|
||||
cvp = self.steamvr / 'drivers/cv/bin/linuxarm64/libArcturusPerception.so'
|
||||
cvp.parent.mkdir(parents=True)
|
||||
cvp.write_bytes(b'updated library')
|
||||
backup = Path(str(cvp) + '.droiddeck-disabled')
|
||||
backup.write_bytes(b'previous library')
|
||||
self.start()
|
||||
self.assertFalse(cvp.exists())
|
||||
self.assertEqual(backup.read_bytes(), b'previous library')
|
||||
self.assertEqual([p.read_bytes() for p in cvp.parent.glob('*.droiddeck-disabled.*')], [b'updated library'])
|
||||
|
||||
def test_start_failure_after_overrides_restores_preferences(self):
|
||||
self.environment['DROIDDECK_VR_PRESENT'] = 'questwsi'
|
||||
path = self.home / '.local/share/Steam/config/steamvr.vrsettings'
|
||||
path.parent.mkdir(parents=True)
|
||||
original = {'steamvr': {'enableLinuxVulkanAsync': False, 'motionSmoothing': True}}
|
||||
path.write_text(json.dumps(original))
|
||||
cvp = self.steamvr / 'drivers/cv/bin/linuxarm64/libArcturusPerception.so'
|
||||
cvp.parent.mkdir(parents=True)
|
||||
cvp.touch()
|
||||
self.executable(self.commands / 'mv', 'exit 1')
|
||||
result = subprocess.run(['sh', str(self.helper), 'start'], env=self.environment,
|
||||
capture_output=True, text=True, timeout=5)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(json.loads(path.read_text()), original)
|
||||
|
||||
def test_explicit_quest_presenter_enables_the_lease(self):
|
||||
self.environment['DROIDDECK_VR_PRESENT'] = 'questframes'
|
||||
self.assertIn('present=questframes lease=1', self.lease_log())
|
||||
|
||||
def test_explicit_diagnostic_override_is_preserved(self):
|
||||
self.environment.update(DROIDDECK_VR_PRESENT='questframes', DROIDDECK_VR_PRODUCER_LEASE='0')
|
||||
self.assertIn('present=questframes lease=0', self.lease_log())
|
||||
|
||||
def test_flat_presenter_does_not_enable_the_producer_lease(self):
|
||||
self.assertIn('present=unset lease=unset', self.lease_log())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,25 @@
|
||||
import json
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("g++"), "needs a Linux C++ compiler")
|
||||
class XrChaperoneTest(unittest.TestCase):
|
||||
def test_seated_origin_and_stage_preservation(self):
|
||||
repository = Path(__file__).resolve().parents[2]
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
executable = Path(directory) / "chaperone-test"
|
||||
subprocess.run(["g++", "-std=c++17", "-Wall", "-Wextra", "-Werror", "-O2",
|
||||
str(repository / "tools/vr/tests/test_xr_chaperone.cpp"), "-o", str(executable)], check=True)
|
||||
result = json.loads(subprocess.check_output([str(executable)], text=True))
|
||||
self.assertEqual((result["jsonid"], result["version"]), ("chaperone_info", 5))
|
||||
self.assertEqual(result["time"], "2026-10-15T21:00:00Z")
|
||||
universe, = result["universes"]
|
||||
self.assertEqual(int(universe["universeID"]), 2)
|
||||
self.assertEqual(universe["standing"], {"translation": [0, 0, 0], "yaw": 0})
|
||||
self.assertEqual(universe["collision_bounds"], [])
|
||||
self.assertEqual(universe["play_area"], [0, 0])
|
||||
self.assertAlmostEqual(universe["seated"]["translation"][1], -1.6, places=6)
|
||||
@@ -0,0 +1,45 @@
|
||||
import ctypes.util
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("gcc"), "needs gcc on a Linux host")
|
||||
class VrProducerLeaseTest(unittest.TestCase):
|
||||
def compile_and_run(self, source, headers=None, gpu=False):
|
||||
repository = Path(__file__).resolve().parents[2]
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
executable = Path(directory) / "producer-test"
|
||||
command = ["gcc", "-std=c11", "-O2", "-Wall", "-Wextra", "-Werror", "-Wno-unused-parameter", "-pthread"]
|
||||
if headers:
|
||||
command += ["-I" + str(headers)]
|
||||
command += [str(repository / "tools/vr/tests" / source), "-ldl"]
|
||||
if gpu:
|
||||
command += ["-l:libvulkan.so.1"]
|
||||
subprocess.run(command + ["-o", str(executable)], check=True)
|
||||
environment = dict(os.environ)
|
||||
if gpu:
|
||||
manifests = sorted(Path("/usr/share/vulkan/icd.d").glob("lvp_icd*.json"))
|
||||
environment["VK_DRIVER_FILES"] = str(manifests[0])
|
||||
environment["VK_ICD_FILENAMES"] = str(manifests[0])
|
||||
result = subprocess.run([str(executable)], env=environment, capture_output=True, text=True, timeout=20)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
return result.stdout
|
||||
|
||||
def test_protocol_and_retained_ownership(self):
|
||||
self.assertIn("disconnect quarantine passed", self.compile_and_run("test_producer_lease.c"))
|
||||
|
||||
def test_real_gpu_completion_and_frozen_overwrite(self):
|
||||
if not ctypes.util.find_library("vulkan") or not list(Path("/usr/share/vulkan/icd.d").glob("lvp_icd*.json")):
|
||||
self.skipTest("needs Vulkan loader and Lavapipe")
|
||||
repository = Path(__file__).resolve().parents[2]
|
||||
candidates = [os.environ.get("VK_INCLUDE", ""), "/usr/include", repository / "build/vr/include"]
|
||||
candidates += [path for root in (os.environ.get("ANDROID_HOME"), os.environ.get("ANDROID_SDK_ROOT")) if root
|
||||
for path in Path(root).glob("ndk/*/toolchains/llvm/prebuilt/*/sysroot/usr/include")]
|
||||
headers = next((Path(path) for path in candidates if path and (Path(path) / "vulkan/vk_layer.h").is_file()), None)
|
||||
if headers is None:
|
||||
self.skipTest("needs Vulkan headers")
|
||||
self.assertIn("1024 buffer values passed", self.compile_and_run("test_producer_gpu.c", headers=headers, gpu=True))
|
||||
@@ -0,0 +1,26 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which("gcc"), "needs gcc on a Linux host")
|
||||
class VrSemaphoreLayerTest(unittest.TestCase):
|
||||
def test_waits_are_never_fabricated(self):
|
||||
repository = Path(__file__).resolve().parents[2]
|
||||
candidates = [os.environ.get("VK_INCLUDE", ""), "/usr/include", repository / "build/vr/include"]
|
||||
candidates += [path for root in (os.environ.get("ANDROID_HOME"), os.environ.get("ANDROID_SDK_ROOT")) if root
|
||||
for path in Path(root).glob("ndk/*/toolchains/llvm/prebuilt/*/sysroot/usr/include")]
|
||||
headers = next((Path(path) for path in candidates if path and (Path(path) / "vulkan/vk_layer.h").is_file()), None)
|
||||
if headers is None:
|
||||
self.skipTest("needs Vulkan headers")
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
executable = Path(directory) / "semaphore-layer-test"
|
||||
subprocess.run(["gcc", "-std=c11", "-O2", "-Wall", "-Wextra", "-Werror", "-Wno-unused-parameter",
|
||||
"-pthread", "-I" + str(headers), str(repository / "tools/vr/tests/test_semaphore_layer.c"),
|
||||
"-ldl", "-o", str(executable)], check=True)
|
||||
result = subprocess.run([str(executable)], capture_output=True, text=True, timeout=20)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
self.assertIn("fd ownership passed", result.stdout)
|
||||
@@ -0,0 +1,23 @@
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
@unittest.skipUnless(shutil.which('g++'), 'needs a Linux C++ compiler')
|
||||
class VrWsiTest(unittest.TestCase):
|
||||
def test_compositor_handoff_and_frame_transport(self):
|
||||
repository = Path(__file__).resolve().parents[2]
|
||||
headers = next((p for p in (Path('/usr/include'), repository / 'build/vr/include')
|
||||
if (p / 'vulkan/vulkan.h').is_file()), None)
|
||||
if headers is None:
|
||||
self.skipTest('needs Vulkan headers')
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
for name in ('test_wsi_capture', 'test_xr_shared', 'test_xr_frames', 'test_xr_gpu'):
|
||||
with self.subTest(name=name):
|
||||
executable = Path(directory) / name
|
||||
subprocess.run(['g++', '-std=c++17', '-O2', '-pthread', '-Wall', '-Wextra', '-Werror',
|
||||
'-Wno-missing-field-initializers', '-I' + str(headers),
|
||||
str(repository / 'tools/vr/tests' / (name + '.cpp')), '-o', str(executable)], check=True)
|
||||
subprocess.run([str(executable)], check=True, timeout=20)
|
||||
Reference in new issue
Block a user