460 lines
17 KiB
GDScript
460 lines
17 KiB
GDScript
extends GutTest
|
|
|
|
class BaseTestClass:
|
|
extends GutInternalTester
|
|
# !! Use this for debugging to see the results of all the subtests that
|
|
# are run using assert_fail_pass, assert_fail and assert_pass that are
|
|
# built into this class
|
|
var _print_all_subtests = false
|
|
|
|
# GlobalReset(gr) variables to be used by tests.
|
|
# The values of these are reset in the setup or
|
|
# teardown methods.
|
|
var gr = {
|
|
test = null,
|
|
signal_object = null,
|
|
test_with_gut = null
|
|
}
|
|
|
|
|
|
|
|
# #############
|
|
# Seutp/Teardown
|
|
# #############
|
|
func before_each():
|
|
# Everything in here uses the same logger (the one in `g`) since there
|
|
# should not be any times when they would need to be different and
|
|
# `new_gut` sets up the logger to be more quiet.
|
|
var g = autofree(new_gut(_print_all_subtests))
|
|
g.log_level = 3
|
|
|
|
gr.test = Test.new()
|
|
gr.test.set_logger(g.logger)
|
|
|
|
gr.test_with_gut = Test.new()
|
|
gr.test_with_gut.gut = g
|
|
gr.test_with_gut.set_logger(g.logger)
|
|
add_child(gr.test_with_gut.gut)
|
|
|
|
func after_each():
|
|
gr.test_with_gut.gut.get_spy().clear()
|
|
|
|
gr.test.free()
|
|
gr.test = null
|
|
gr.test_with_gut.gut.free()
|
|
gr.test_with_gut.free()
|
|
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class TestSignalAsserts:
|
|
extends BaseTestClass
|
|
|
|
# Constants for all the signals created in SignalObject so I don't get false
|
|
# pass/fail from typos
|
|
const SIGNALS = {
|
|
NO_PARAMETERS = 'no_parameters',
|
|
ONE_PARAMETER = 'one_parameter',
|
|
TWO_PARAMETERS = 'two_parameters',
|
|
SOME_SIGNAL = 'some_signal',
|
|
SCRIPT_SIGNAL = 'script_signal'
|
|
}
|
|
|
|
# ####################
|
|
# A class that can emit all the signals in SIGNALS
|
|
# ####################
|
|
class SignalObject:
|
|
signal script_signal
|
|
|
|
func _init():
|
|
add_user_signal(SIGNALS.NO_PARAMETERS)
|
|
add_user_signal(SIGNALS.ONE_PARAMETER, [
|
|
{'name':'something', 'type':TYPE_INT}
|
|
])
|
|
add_user_signal(SIGNALS.TWO_PARAMETERS, [
|
|
{'name':'num', 'type':TYPE_INT},
|
|
{'name':'letters', 'type':TYPE_STRING}
|
|
])
|
|
add_user_signal(SIGNALS.SOME_SIGNAL)
|
|
|
|
func before_each():
|
|
super.before_each()
|
|
gr.signal_object = SignalObject.new()
|
|
|
|
func after_each():
|
|
super.after_each()
|
|
gr.signal_object = null
|
|
|
|
func test_when_object_not_being_watched__assert_signal_emitted__fails():
|
|
gr.test.assert_signal_emitted(gr.signal_object, SIGNALS.SOME_SIGNAL)
|
|
assert_fail(gr.test)
|
|
|
|
func test_when_signal_emitted__assert_signal_emitted__passes():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.test.assert_signal_emitted(gr.signal_object, SIGNALS.SOME_SIGNAL)
|
|
assert_pass(gr.test)
|
|
|
|
func test_when_signal_not_emitted__assert_signal_emitted__fails():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_emitted(gr.signal_object, SIGNALS.SOME_SIGNAL)
|
|
assert_fail(gr.test)
|
|
|
|
func test_when_object_does_not_have_signal__assert_signal_emitted__fails():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_emitted(gr.signal_object, 'signal_does_not_exist')
|
|
assert_fail(gr.test, 1, 'Only the failure that it does not have signal should fire.')
|
|
|
|
func test_when_signal_emitted__assert_signal_not_emitted__fails():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.test.assert_signal_not_emitted(gr.signal_object, SIGNALS.SOME_SIGNAL)
|
|
assert_fail(gr.test)
|
|
|
|
func test_when_signal_not_emitted__assert_signal_not_emitted__fails():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_not_emitted(gr.signal_object, SIGNALS.SOME_SIGNAL)
|
|
assert_pass(gr.test)
|
|
|
|
func test_when_object_does_not_have_signal__assert_signal_not_emitted__fails():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_not_emitted(gr.signal_object, 'signal_does_not_exist')
|
|
assert_fail(gr.test, 1, 'Only the failure that it does not have signal should fire.')
|
|
|
|
func test_when_signal_emitted_once__assert_signal_emit_count__passes_with_1():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.test.assert_signal_emit_count(gr.signal_object, SIGNALS.SOME_SIGNAL, 1)
|
|
assert_pass(gr.test)
|
|
|
|
func test_when_signal_emitted_twice__assert_signal_emit_count__fails_with_1():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.test.assert_signal_emit_count(gr.signal_object, SIGNALS.SOME_SIGNAL, 1)
|
|
assert_fail(gr.test)
|
|
|
|
func test_when_object_does_not_have_signal__assert_signal_emit_count__fails():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_emit_count(gr.signal_object, 'signal_does_not_exist', 0)
|
|
assert_fail(gr.test)
|
|
|
|
func test_assert_signal_emit_count_accepts_signal_instead_of_name():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.script_signal.emit()
|
|
gr.test.assert_signal_emit_count(gr.signal_object.script_signal, 1)
|
|
assert_pass(gr.test)
|
|
|
|
func test_assert_signal_emit_count_uses_text_when_signal_passed_instead_of_name():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
# gr.signal_object.script_signal.emit()
|
|
gr.test.assert_signal_emit_count(gr.signal_object.script_signal, 1, '__foo__')
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, '__foo__')
|
|
|
|
func test__assert_has_signal__passes_when_it_has_the_signal():
|
|
gr.test.assert_has_signal(gr.signal_object, SIGNALS.NO_PARAMETERS)
|
|
assert_pass(gr.test)
|
|
|
|
func test__assert_has_signal__fails_when_it_does_not_have_the_signal():
|
|
gr.test.assert_has_signal(gr.signal_object, 'signal does not exist')
|
|
assert_fail(gr.test)
|
|
|
|
func test_can_get_signal_emit_counts():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
assert_eq(gr.test.get_signal_emit_count(gr.signal_object, SIGNALS.SOME_SIGNAL), 2)
|
|
|
|
func test_text_included_in_output_when_signal_name_passed():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_emitted(gr.signal_object, 'script_signal', '__foo__')
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, '__foo__')
|
|
|
|
func test_accepts_signal_object_instead_of_name():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.script_signal.emit()
|
|
gr.test.assert_signal_emitted(gr.signal_object.script_signal)
|
|
assert_pass(gr.test)
|
|
|
|
func test_text_included_in_output_when_signal_passed():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_emitted(gr.signal_object.script_signal, '__foo__')
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, '__foo__')
|
|
|
|
func test_not_text_included_in_output_when_signal_name_passed():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.script_signal.emit()
|
|
gr.test.assert_signal_not_emitted(gr.signal_object, 'script_signal', '__foo__')
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, '__foo__')
|
|
|
|
func test_not_accepts_signal_object_instead_of_name():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_not_emitted(gr.signal_object.script_signal)
|
|
assert_pass(gr.test)
|
|
|
|
func test_not_text_included_in_output_when_signal_passed():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_not_emitted(gr.signal_object.script_signal, '__foo__')
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, '__foo__')
|
|
|
|
func test_text_is_empty_string_when_only_signal_object_is_passed():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_emitted(gr.signal_object, 'script_signal')
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, ']: (')
|
|
|
|
|
|
# ------------------
|
|
# With Parameters
|
|
func test__with_parameters_errors_when_parameters_are_not_an_array():
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, 1)
|
|
assert_logger_errored(gr.test)
|
|
assert_fail(gr.test)
|
|
|
|
func test__assert_signal_emitted_with_parameters__fails_when_object_not_watched():
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [])
|
|
assert_fail(gr.test)
|
|
|
|
func test__assert_signal_emitted_with_parameters__passes_when_parameters_match():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL, 1)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [1])
|
|
assert_pass(gr.test)
|
|
|
|
|
|
func test__assert_signal_emitted_with_parameters__passes_when_all_parameters_match():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL, 1, 2, 3)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [1, 2, 3])
|
|
assert_pass(gr.test)
|
|
|
|
func test__assert_signal_emitted_with_parameters__fails_when_signal_not_emitted():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [2])
|
|
assert_fail(gr.test)
|
|
|
|
func test__assert_signal_emitted_with_parameters__fails_when_parameters_dont_match():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL, 1)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [2])
|
|
assert_fail(gr.test)
|
|
|
|
func test__assert_signal_emitted_with_parameters__fails_when_not_all_parameters_match():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL, 1, 2, 3)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [1, 0, 3])
|
|
assert_fail(gr.test)
|
|
|
|
func test__assert_signal_emitted_with_parameters__can_check_multiple_emission():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL, 1)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL, 2)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [1], 0)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [2], 1)
|
|
assert_pass(gr.test, 2)
|
|
|
|
func test_when_signal_emit_with_parameters_fails_because_signal_was_not_emitted_then_signals_are_listed():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.NO_PARAMETERS)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SCRIPT_SIGNAL, [0])
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, SIGNALS.NO_PARAMETERS)
|
|
assert_string_contains(text, SIGNALS.SOME_SIGNAL)
|
|
|
|
func test_issue_152():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL, 1.0, 2, 3.0)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, [1, 2.0, 3])
|
|
assert_fail(gr.test)
|
|
|
|
func test_accepts_signal_instead_of_signal_name():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.script_signal.emit(1, 2, 3)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object.script_signal, [1, 2, 3])
|
|
assert_pass(gr.test)
|
|
|
|
func test_accepts_signal_instead_of_signal_name_and_index():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.script_signal.emit(1, 2, 3)
|
|
gr.signal_object.script_signal.emit(4, 5, 6)
|
|
gr.test.assert_signal_emitted_with_parameters(gr.signal_object.script_signal, [1, 2, 3], 0)
|
|
assert_pass(gr.test)
|
|
|
|
|
|
func test_can_get_signal_parameters():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL, 1, 2, 3)
|
|
assert_eq(gr.test.get_signal_parameters(gr.signal_object, SIGNALS.SOME_SIGNAL, 0), [1, 2, 3])
|
|
|
|
func test_can_get_signal_parameters_using_signal_object_instead_of_name():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.script_signal.emit(1, 2, 3)
|
|
assert_eq(gr.test.get_signal_parameters(gr.signal_object.script_signal, 0), [1, 2, 3])
|
|
|
|
func test_can_get_signal_parameters_using_signal_object_instead_of_name_without_index():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.script_signal.emit(1, 2, 3)
|
|
assert_eq(gr.test.get_signal_parameters(gr.signal_object.script_signal), [1, 2, 3])
|
|
|
|
func test_can_get_signal_parameters_using_signal_object_instead_of_name_with_different_index():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.script_signal.emit(1, 2, 3)
|
|
gr.signal_object.script_signal.emit(4, 5, 6)
|
|
gr.signal_object.script_signal.emit(7, 8, 9)
|
|
assert_eq(gr.test.get_signal_parameters(gr.signal_object.script_signal, 1), [4, 5, 6])
|
|
|
|
|
|
func test__assert_signal_emitted__passes_with_script_signals():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.SCRIPT_SIGNAL)
|
|
gr.test.assert_signal_emitted(gr.signal_object, SIGNALS.SCRIPT_SIGNAL)
|
|
assert_pass(gr.test)
|
|
|
|
func test__assert_has_signal__works_with_script_signals():
|
|
gr.test.assert_has_signal(gr.signal_object, SIGNALS.SCRIPT_SIGNAL)
|
|
assert_pass(gr.test)
|
|
|
|
func test_when_signal_emitted_fails_emitted_signals_are_listed():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.NO_PARAMETERS)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.test.assert_signal_emitted(gr.signal_object, SIGNALS.SCRIPT_SIGNAL)
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, SIGNALS.NO_PARAMETERS)
|
|
assert_string_contains(text, SIGNALS.SOME_SIGNAL)
|
|
|
|
func test_when_signal_count_fails_then_emitted_signals_are_listed():
|
|
gr.test.watch_signals(gr.signal_object)
|
|
gr.signal_object.emit_signal(SIGNALS.NO_PARAMETERS)
|
|
gr.signal_object.emit_signal(SIGNALS.SCRIPT_SIGNAL)
|
|
gr.signal_object.emit_signal(SIGNALS.SOME_SIGNAL)
|
|
gr.test.assert_signal_emit_count(gr.signal_object, SIGNALS.SCRIPT_SIGNAL, 2)
|
|
var text = gr.test._fail_pass_text[0]
|
|
assert_string_contains(text, SIGNALS.NO_PARAMETERS)
|
|
assert_string_contains(text, SIGNALS.SOME_SIGNAL)
|
|
|
|
func test__get_signal_emit_count__returns_neg_1_when_not_watched():
|
|
assert_eq(gr.test.get_signal_emit_count(gr.signal_object, SIGNALS.SOME_SIGNAL), -1)
|
|
|
|
func test_get_signal_emit_count_works_with_signal_ref():
|
|
assert_eq(gr.test.get_signal_emit_count(gr.signal_object.script_signal), -1)
|
|
|
|
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
class TestConnectionAsserts:
|
|
extends BaseTestClass
|
|
|
|
const SIGNAL_NAME = 'test_signal'
|
|
const METHOD_NAME = 'test_signal_connector'
|
|
|
|
class Signaler:
|
|
signal test_signal
|
|
|
|
class ConnectTo:
|
|
func test_signal_connector():
|
|
pass
|
|
|
|
func test_when_target_connected_to_source_connected_passes_with_method_name():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
s.connect(SIGNAL_NAME,Callable(c,METHOD_NAME))
|
|
gr.test.assert_connected(s, c, SIGNAL_NAME, METHOD_NAME)
|
|
assert_pass(gr.test)
|
|
|
|
func test_when_target_connected_to_source_connected_passes_without_method_name():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
s.connect(SIGNAL_NAME,Callable(c,METHOD_NAME))
|
|
gr.test.assert_connected(s, c, SIGNAL_NAME)
|
|
assert_pass(gr.test)
|
|
|
|
func test_when_target_not_connected_to_source_connected_fails_with_method_name():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
gr.test.assert_connected(s, c, SIGNAL_NAME, METHOD_NAME)
|
|
assert_fail(gr.test)
|
|
|
|
func test_when_target_not_connected_to_source_connected_fails_without_method_name():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
gr.test.assert_connected(s, c, SIGNAL_NAME)
|
|
assert_fail(gr.test)
|
|
|
|
func test_when_target_connected_to_source_not_connected_fails_with_method_name():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
s.connect(SIGNAL_NAME,Callable(c,METHOD_NAME))
|
|
gr.test.assert_not_connected(s, c, SIGNAL_NAME, METHOD_NAME)
|
|
assert_fail(gr.test)
|
|
|
|
func test_when_target_connected_to_source_not_connected_fails_without_method_name():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
s.connect(SIGNAL_NAME,Callable(c,METHOD_NAME))
|
|
gr.test.assert_not_connected(s, c, SIGNAL_NAME)
|
|
assert_fail(gr.test)
|
|
|
|
func test_when_target_not_connected_to_source_not_connected_passes_with_method_name():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
gr.test.assert_not_connected(s, c, SIGNAL_NAME, METHOD_NAME)
|
|
assert_pass(gr.test)
|
|
|
|
func test_when_target_not_connected_to_source_not_connected_passes_without_method_name():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
gr.test.assert_not_connected(s, c, SIGNAL_NAME)
|
|
assert_pass(gr.test)
|
|
|
|
func test_assert_connected_accepts_objects_instead_of_names():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
s.test_signal.connect(c.test_signal_connector)
|
|
gr.test.assert_connected(s.test_signal, c)
|
|
assert_pass(gr.test)
|
|
|
|
func test_assert_connected_works_with_callable():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
s.test_signal.connect(c.test_signal_connector)
|
|
gr.test.assert_connected(s.test_signal, c.test_signal_connector)
|
|
assert_pass(gr.test)
|
|
|
|
func test_assert_not_connected_accepts_objects_instead_of_names():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
s.test_signal.connect(c.test_signal_connector)
|
|
gr.test.assert_not_connected(s.test_signal, c)
|
|
assert_fail(gr.test)
|
|
|
|
func test_assert_not_connected_works_with_callable():
|
|
var s = Signaler.new()
|
|
var c = ConnectTo.new()
|
|
s.test_signal.connect(c.test_signal_connector)
|
|
gr.test.assert_not_connected(s.test_signal, c.test_signal_connector)
|
|
assert_fail(gr.test)
|
|
|
|
func test_assert_connected_works_with_anonymous_function():
|
|
var s = Signaler.new()
|
|
var f = func():
|
|
pass
|
|
s.test_signal.connect(f)
|
|
gr.test.assert_connected(s.test_signal, f)
|
|
assert_pass(gr.test)
|
|
|
|
func test_assert_not_connected_works_with_anonymous_function():
|
|
var s = Signaler.new()
|
|
var f = func():
|
|
pass
|
|
s.test_signal.connect(f)
|
|
gr.test.assert_not_connected(s.test_signal, f)
|
|
assert_fail(gr.test)
|