def action_discover(args, test_step, expected, params_list): if args.controller_type == 'c': # Can take up to 20 seconds to timeout entities which have disappeared yield base.sleep(20) print_title("Command: list") args.master.sendLine(args.controller_id, "list") yield base.sleep(2) else: args.master.clearExpectHistory(args.controller_id) print_title("Command: discover") args.master.sendLine(args.controller_id, "discover") yield args.master.expect(Expected(args.controller_id, "Found \d+ entities", 15)) # Actually check that the right number of entities have been seen visible_endpoints = graph.get_endpoints_connected_to(state.get_current(), args.controller_id) controller = getActiveProcesses()[args.controller_id] if len(controller.entities) != len(visible_endpoints): base.testError("Found %d entities, expecting %d" % (len(controller.entities), len(visible_endpoints)), critical=True) else: log_info("Found %d entities" % len(controller.entities)) yield args.master.expect(None)
def startXrun(combined_args): (name, process, adapter_id, bin, args) = combined_args # Windows requires the absolute path of xrun exe_name = base.exe_name('xrun') xrun = base.file_abspath(exe_name) log_info("Starting %s (%s)" % (name, ' '.join(['--adapter-id', adapter_id, '--xscope', '--xscope-file', name + '.xmt', bin]))) reactor.spawnProcess(process, xrun, [xrun, '--adapter-id', adapter_id, '--xscope', '--xscope-file', name + '.xmt', bin], env=os.environ, path=args.logdir)
def set_seed(args, test_config): """ Set the seed from the config file, unless overridden by the command-line """ seed = 1 if args.seed is not None: seed = args.seed elif 'seed' in test_config: seed = test_config['seed'] log_info("Running test with seed {seed}".format(seed=seed)) random.seed(seed)
def startXrunWithDelay(rootDir, master, delay, name, adapter_id, args): # Need to ensure that the endpoint and process are created and registered before the # master task is started ep = process.XrunProcess(name, master, output_file=os.path.join(args.logdir, name + '_console.log')) ep_bin = os.path.join(rootDir, 'sw_avb_dc', 'app_daisy_chain', 'bin', 'app_daisy_chain.xe') log_info("Starting %s in %.3f" % (name, delay)) d = defer.Deferred() reactor.callLater(delay, d.callback, (name, ep, adapter_id, ep_bin, args)) d.addCallback(startXrun)
def startAnalyzer(combined_args): (name, adapter_id, target_bin, analyzer_bin, target_process, analyzer_process, port, args) = combined_args # Windows requires the absolute path of xrun exe_name = base.exe_name('xrun') xrun = base.file_abspath(exe_name) log_info("Starting analyzer %s" % name) reactor.spawnProcess(target_process, xrun, [xrun, '--adapter-id', adapter_id, '--xscope-port', 'localhost:%d' % port, target_bin], env=os.environ, path=args.logdir) reactor.spawnProcess(analyzer_process, analyzer_bin, [analyzer_bin, '-p', '%d' % port], env=os.environ, path=args.logdir)
def start_generator_with_delay(rootDir, master, delay, name, adapter_id, generator, args): # Need to ensure that the endpoint and process are created and registered before the # master task is started generator_process = process.Process(name, master, output_file=os.path.join(args.logdir, name + '_console.log')) target_name = name + '_target' target_process = process.XrunProcess(target_name, master, output_file=os.path.join(args.logdir, target_name + '_console.log')) target_bin = os.path.join(rootDir, 'sw_ethernet_traffic_gen', 'app_traffic_gen', 'bin', 'app_traffic_gen.xe') generator_bin = os.path.join(rootDir, 'sw_ethernet_traffic_gen', 'host_traffic_gen', 'traffic_gen_controller') log_info("Starting generator %s in %.3f" % (name, delay)) d = defer.Deferred() reactor.callLater(delay, d.callback, (name, adapter_id, target_bin, generator_bin, target_process, generator_process, generator['port'], args)) d.addCallback(start_generator)
def configure_generators(): """ Ensure the generators have started properly """ generator_startup = [Expected(a, "connected to .*: %d" % generators.get_port(a), 15, critical=True) for a in generators.get_all()] yield master.expect(AllOf(generator_startup)) for (name,generator) in generators.get_all().iteritems(): log_info("Configure %s" % name) # Configure a random mix of unicast, multicast and broadcast traffic master.sendLine(name, "c u 1 64 1500") master.sendLine(name, "c m 1 64 1500") master.sendLine(name, "c b 1 64 1500") # Apply the specified config master.sendLine(name, "e") # Apply the specified config master.sendLine(name, "p") yield master.expect(Expected(name, "Current configuration", 5))
def configure_analyzers(): """ Ensure the analyzers have started properly and then configure their channel frequencies as specified in the test configuration file """ analyzer_startup = [Expected(a, "connected to .*: %d" % analyzers.get_port(a), 15, critical=True) for a in analyzers.get_all()] yield master.expect(AllOf(analyzer_startup)) for (name,analyzer) in analyzers.get_all().iteritems(): if analyzer['type'] != 'audio': continue log_info("Configure %s" % name) # Disable all channels master.sendLine(name, "d a") yield master.expect(Expected(name, "Channel 0: disabled", 15)) # Set the base channel index analyzer_base = analyzer['base'] master.sendLine(name, "b %d" % analyzer_base) # Configure all channels for (chan_id,freq) in analyzer['frequencies'].iteritems(): # Need to convert unicode to string before sending as a command chan = int(chan_id) master.sendLine(name, "c %d %d" % (chan, freq)) # The channel ID is offset from the base in the generating message yield master.expect( Expected(name, "Generating sine table for chan %d" % (chan - analyzer_base), 15)) master.sendLine(name, "e a") channel_enables = [Expected(name, "Channel %d: enabled" % (int(c) - analyzer_base), 15) for c in analyzer['frequencies'].keys()] yield master.expect(AllOf(channel_enables))
def check_endpoint_startup(): """ Ensure that the endpoints have started correctly. The exact sequence will depend on which endpoint is the grandmaster. """ grandmaster = endpoints.determine_grandmaster(args.user) log_info("Using grandmaster {gm_id}".format(gm_id=endpoints.get_avb_id(args.user, grandmaster))) # Check that all endpoints go to PTP master in 30 seconds and then one of the # ports will go Master or Slave and lock ptp_startup = [AllOf( [ptp_startup_two_port(e, grandmaster, args.user) for e in filter(lambda x: x['ports'] == 2, endpoints.get_all().values())] + [ptp_startup_single_port(e, grandmaster, args.user) for e in filter(lambda x: x['ports'] == 1, endpoints.get_all().values())] )] maap = [ AllOf([Expected(e['name'], 'MAAP reserved Talker stream #%d address: 91:E0:F0:0' % n, 40) for n in range(e['talker_streams'])]) for e in endpoints.get_all().values() ] yield master.expect(AllOf(ptp_startup + maap))
def startAnalyzerWithDelay(rootDir, master, delay, name, adapter_id, analyzer, args): # Need to ensure that the endpoint and process are created and registered before the # master task is started analyzer_process = process.Process(name, master, output_file=os.path.join(args.logdir, name + '_console.log')) target_name = name + '_target' target_process = process.XrunProcess(target_name, master, output_file=os.path.join(args.logdir, target_name + '_console.log')) if analyzer['type'] == 'audio': target_bin = os.path.join(rootDir, 'sw_audio_analyzer', 'app_audio_analyzer_avb', 'bin', 'audio_analyzer.xe') analyzer_bin = os.path.join(rootDir, 'sw_audio_analyzer', 'host_audio_analyzer', 'audio_analyzer') elif analyzer['type'] == 'qav': target_bin = os.path.join(rootDir, 'sw_ethernet_tap', 'app_avb_tester', 'bin', 'app_avb_tester.xe') analyzer_bin = os.path.join(rootDir, 'sw_ethernet_tap', 'host_avb_tester', 'avb_tester') else: test_error("%s: unknown type '%s'" % (name, analyzer['type']), critical=True) log_info("Starting %s analyzer %s in %.3f" % (analyzer['type'], name, delay)) d = defer.Deferred() reactor.callLater(delay, d.callback, (name, adapter_id, target_bin, analyzer_bin, target_process, analyzer_process, analyzer['port'], args)) d.addCallback(startAnalyzer)
def print_title(title): log_info("\n%s\n%s\n" % (title, '=' * len(title)))
def print_comment(test_step): comment = getattr(test_step, 'comment', None) if comment is not None: log_info("\n>> %s\n" % comment)