You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
181 lines
8.1 KiB
181 lines
8.1 KiB
2 months ago
|
# License: Apache 2.0. See LICENSE file in root directory.
|
||
|
|
# Copyright(c) 2022 Intel Corporation. All Rights Reserved.
|
||
|
|
|
||
|
|
#test:donotrun:!dds
|
||
|
|
#test:retries:gha 2
|
||
|
|
|
||
|
|
import pyrealdds as dds
|
||
|
|
from rspy import log, test
|
||
|
|
import d435i
|
||
|
|
from time import sleep
|
||
|
|
|
||
|
|
|
||
|
|
dds.debug( log.is_debug_on(), 'C ' )
|
||
|
|
log.nested = 'C '
|
||
|
|
|
||
|
|
|
||
|
|
participant = dds.participant()
|
||
|
|
participant.init( 123, "test-device-init" )
|
||
|
|
|
||
|
|
info = dds.message.device_info()
|
||
|
|
info.name = "Test Device"
|
||
|
|
info.topic_root = "realdds/device/topic-root"
|
||
|
|
|
||
|
|
|
||
|
|
import os.path
|
||
|
|
cwd = os.path.dirname(os.path.realpath(__file__))
|
||
|
|
remote_script = os.path.join( cwd, 'device-init-server.py' )
|
||
|
|
second_client_script = os.path.join( cwd, 'device-2nd-client.py' )
|
||
|
|
with test.remote( remote_script, nested_indent=" S" ) as remote:
|
||
|
|
remote.wait_until_ready()
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
#
|
||
|
|
with test.closure( "Test 1 stream..." ):
|
||
|
|
remote.run( 'test_one_stream()' )
|
||
|
|
device = dds.device( participant, info )
|
||
|
|
device.wait_until_ready() # If no device is available before timeout, this will throw
|
||
|
|
test.check( device.is_ready() )
|
||
|
|
test.check_equal( device.n_streams(), 1 )
|
||
|
|
for stream in device.streams():
|
||
|
|
profiles = stream.profiles()
|
||
|
|
test.check_equal( stream.name(), "s1" )
|
||
|
|
test.check_equal( stream.sensor_name(), "sensor" )
|
||
|
|
test.check_equal( len( profiles ), 1 )
|
||
|
|
test.check_equal( str(profiles[0]), "<pyrealdds.depth_stream_profile 's1' 10x10 rgb8 @ 9 Hz>" )
|
||
|
|
test.check_equal( profiles[0].stream(), stream )
|
||
|
|
test.check_equal( stream.default_profile_index(), 0 )
|
||
|
|
remote.run( 'close_server()' )
|
||
|
|
device = None
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
#
|
||
|
|
with test.closure( "Test motion stream..." ):
|
||
|
|
remote.run( 'test_one_motion_stream()' )
|
||
|
|
device = dds.device( participant, info )
|
||
|
|
device.wait_until_ready() # If no device is available before timeout, this will throw
|
||
|
|
test.check( device.is_ready() )
|
||
|
|
test.check_equal( device.n_streams(), 1 )
|
||
|
|
for stream in device.streams():
|
||
|
|
profiles = stream.profiles()
|
||
|
|
test.check_equal( stream.name(), "s2" )
|
||
|
|
test.check_equal( stream.sensor_name(), "sensor2" )
|
||
|
|
test.check_equal( stream.type_string(), "motion" )
|
||
|
|
test.check_equal( len( profiles ), 1 )
|
||
|
|
test.check_equal( str(profiles[0]), "<pyrealdds.motion_stream_profile 's2' @ 30 Hz>" )
|
||
|
|
test.check_equal( profiles[0].stream(), stream )
|
||
|
|
test.check_equal( stream.default_profile_index(), 0 )
|
||
|
|
remote.run( 'close_server()' )
|
||
|
|
device = None
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
#
|
||
|
|
with test.closure( "Test no streams..." ):
|
||
|
|
remote.run( 'test_no_streams()' )
|
||
|
|
device = dds.device( participant, info )
|
||
|
|
device.wait_until_ready() # If no device is available before timeout, this will throw
|
||
|
|
test.check( device.is_ready() )
|
||
|
|
test.check_equal( device.n_streams(), 0 )
|
||
|
|
for stream in device.streams():
|
||
|
|
test.unreachable()
|
||
|
|
remote.run( 'close_server()' )
|
||
|
|
device = None
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
#
|
||
|
|
with test.closure( "Test no profiles... (should fail on server side)" ):
|
||
|
|
try:
|
||
|
|
remote.run( 'test_no_profiles()' )
|
||
|
|
except test.remote.Error as e:
|
||
|
|
# this fails because streams require at least one profile
|
||
|
|
test.check_exception( e, test.remote.Error, "[remote] RuntimeError: at least one profile is required to initialize stream 's1'" )
|
||
|
|
device = None
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
#
|
||
|
|
with test.closure( "Test 10 profiles..." ):
|
||
|
|
remote.run( 'test_n_profiles(10)' )
|
||
|
|
device = dds.device( participant, info )
|
||
|
|
device.wait_until_ready() # If no device is available before timeout, this will throw
|
||
|
|
test.check( device.is_ready() )
|
||
|
|
test.check_equal( device.n_streams(), 1 )
|
||
|
|
for stream in device.streams():
|
||
|
|
profiles = stream.profiles()
|
||
|
|
test.check_equal( 10, len( profiles ))
|
||
|
|
# Go thru the profiles, make sure they're in the right order (json is unordered)
|
||
|
|
fibo = [0,1]
|
||
|
|
for i in range(10):
|
||
|
|
v = fibo[-2] + fibo[-1]
|
||
|
|
fibo[-2] = fibo[-1]
|
||
|
|
fibo[-1] = v
|
||
|
|
test.check_equal( profiles[i].width(), i )
|
||
|
|
test.check_equal( profiles[i].height(), v )
|
||
|
|
remote.run( 'close_server()' )
|
||
|
|
device = None
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
#
|
||
|
|
with test.closure( "Test D435i..." ):
|
||
|
|
remote.run( 'test_d435i()' )
|
||
|
|
device = dds.device( participant, d435i.device_info )
|
||
|
|
device.wait_until_ready() # If no device is available before timeout, this will throw
|
||
|
|
test.check( device.is_ready() )
|
||
|
|
test.check_equal( device.n_streams(), 5 )
|
||
|
|
for stream in device.streams():
|
||
|
|
profiles = stream.profiles()
|
||
|
|
remote.run( 'close_server()' )
|
||
|
|
device = None
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
#
|
||
|
|
with test.closure( "Test discovery of another client device..." ):
|
||
|
|
remote.run( 'test_one_stream()' )
|
||
|
|
device = dds.device( participant, info )
|
||
|
|
device.wait_until_ready() # If no device is available before timeout, this will throw
|
||
|
|
test.check( device.is_ready() )
|
||
|
|
test.check_equal( device.n_streams(), 1 )
|
||
|
|
# now start another server, and have it access the device
|
||
|
|
# NOTE: I had trouble nesting another 'with' statement here...
|
||
|
|
with test.remote( second_client_script, name="remote2", nested_indent=" 2 " ) as remote2:
|
||
|
|
remote2.wait_until_ready()
|
||
|
|
remote2.run( 'test_second_device()' )
|
||
|
|
# the notifications for the second client should be sent again from the server -- we
|
||
|
|
# should ignore them...
|
||
|
|
remote2.run( 'close_device()' )
|
||
|
|
remote.run( 'close_server()' )
|
||
|
|
device = None
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
#
|
||
|
|
with test.closure( "Multiple overlapping client initializations" ):
|
||
|
|
remote.run( 'test_one_stream()' )
|
||
|
|
remote.run( 'notification_flood()' )
|
||
|
|
# Start another two clients and have them access the device:
|
||
|
|
# When the device initializations happen concurrently (which is hard to guarrantee) then
|
||
|
|
# initialization messages may get confused and an exception produced. We try 5 times:
|
||
|
|
for i in range(5):
|
||
|
|
if i > 0:
|
||
|
|
# if we get here, there was no exception; we try again with a small pause
|
||
|
|
log.i( f'... iteration {i+1}' )
|
||
|
|
sleep( 1 )
|
||
|
|
with test.remote( second_client_script, name="client1", nested_indent=" 1 " ) as client1:
|
||
|
|
client1.wait_until_ready()
|
||
|
|
with test.remote( second_client_script, name="client2", nested_indent=" 2 " ) as client2:
|
||
|
|
client2.wait_until_ready()
|
||
|
|
with test.remote( second_client_script, name="client3", nested_indent=" 3 " ) as client3:
|
||
|
|
client3.wait_until_ready()
|
||
|
|
with test.remote( second_client_script, name="client4", nested_indent=" 4 " ) as client4:
|
||
|
|
client4.wait_until_ready()
|
||
|
|
client1.run( 'test_second_device()', timeout=None ) # Don't wait until done
|
||
|
|
client2.run( 'test_second_device()', timeout=None )
|
||
|
|
client3.run( 'test_second_device()', timeout=None )
|
||
|
|
client4.run( 'test_second_device()', timeout=None )
|
||
|
|
remote.run( 'close_server()' )
|
||
|
|
|
||
|
|
#
|
||
|
|
#############################################################################################
|
||
|
|
|
||
|
|
|
||
|
|
participant = None
|
||
|
|
test.print_results_and_exit()
|