def test_filter_type_tests_message_filter_function():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
h.helicsFederateSetFlagOption(mFed,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
h.helicsFilterSet(f1, "delay", 2.5)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsFederateHasMessage(mFed) is False
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
h.helicsFederateRequestTimeAsync(fFed, 3.0)
h.helicsFederateRequestTime(mFed, 3.0)
assert h.helicsEndpointHasMessage(p2) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
h.helicsFederateRequestTime(mFed, 3.0)
h.helicsFederateRequestTimeComplete(fFed)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_messagefilter_function():
broker = createBroker(2)
fFed, ffedinfo = createMessageFederate(1, "filter")
mFed, mfedinfo = createMessageFederate(1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random")
f1 = h.helicsFederateRegisterGlobalFilter(fFed,
h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port1")
h.helicsFederateRegisterEndpoint(fFed, "fout", "")
f3 = h.helicsFederateRegisterFilter(fFed,
h.HELICS_FILTER_TYPE_RANDOM_DELAY,
"filter3")
h.helicsFilterAddSourceTarget(f3, "filter/fout")
h.helicsFilterSet(f2, "delay", 2.5)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == 2
data = "hello world"
filt_key = h.helicsFilterGetName(f1)
assert filt_key == "filter1"
filt_key = h.helicsFilterGetName(f2)
assert filt_key == "filter2"
h.helicsEndpointSendMessageRaw(p1, "port2", data.encode())
h.helicsFederateRequestTimeAsync(mFed, 1.0)
grantedtime = h.helicsFederateRequestTime(fFed, 1.0)
assert grantedtime == 1.0
grantedtime = h.helicsFederateRequestTimeComplete(mFed)
assert grantedtime == 1.0
res = h.helicsFederateHasMessage(mFed)
assert res == 0
res = h.helicsEndpointHasMessage(p2)
assert res == 0
# grantedtime = h.helicsFederateRequestTime(fFed, 3.0)
# assert res==h.helics_true
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
# f2 = h.helicsFederateRegisterDestinationFilter(fFed, h.helics_custom_filter, "filter2", "port2")
# ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "")
# f3 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_custom_filter, "", "filter0/fout")
destroyFederate(fFed, ffedinfo)
destroyFederate(mFed, mfedinfo)
time.sleep(1.0)
destroyBroker(broker)
def test_messagefilter_info():
broker = createBroker(2)
fFed, ffedinfo = createMessageFederate(1, "filter")
mFed, mfedinfo = createMessageFederate(1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
h.helicsEndpointSetInfo(p1, "p1_test")
h.helicsEndpointSetInfo(p2, "p2_test")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
h.helicsFilterSetInfo(f1, "f1_test")
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port2")
h.helicsFilterSetInfo(f2, "f2_test")
ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "")
h.helicsEndpointSetInfo(ep1, "ep1_test")
f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"c4")
h.helicsFilterAddSourceTarget(f3, "filter0/fout")
h.helicsFilterSetInfo(f3, "f3_test")
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
filter_name = h.helicsFilterGetName(f1)
assert filter_name == "Testfilter/filter1"
filter_name = h.helicsFilterGetName(f2)
assert filter_name == "Testfilter/filter2"
assert h.helicsEndpointGetInfo(p1) == "p1_test"
assert h.helicsEndpointGetInfo(p2) == "p2_test"
assert h.helicsEndpointGetInfo(ep1) == "ep1_test"
assert h.helicsFilterGetInfo(f1) == "f1_test"
assert h.helicsFilterGetInfo(f2) == "f2_test"
assert h.helicsFilterGetInfo(f3) == "f3_test"
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
destroyFederate(fFed, ffedinfo)
destroyFederate(mFed, mfedinfo)
time.sleep(1.0)
destroyBroker(broker)
def test_messagefederate_send_receive_2fed_multisend():
broker = createBroker(2)
mFed1, fedinfo1 = createMessageFederate(1, "A Federate")
mFed2, fedinfo2 = createMessageFederate(1, "B Federate")
epid1 = h.helicsFederateRegisterEndpoint(mFed1, "ep1", "")
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed2, "ep2", "random")
h.helicsEndpointSetOption(epid1, h.HELICS_HANDLE_OPTION_IGNORE_INTERRUPTS,
True)
h.helicsFederateSetTimeProperty(mFed1, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateSetTimeProperty(mFed2, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateEnterExecutingModeAsync(mFed1)
h.helicsFederateEnterExecutingMode(mFed2)
h.helicsFederateEnterExecutingModeComplete(mFed1)
assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed1)
assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed2)
h.helicsEndpointSetDefaultDestination(epid1, "ep2")
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsFederateRequestTimeAsync(mFed1, 1.0)
granted_time = h.helicsFederateRequestTime(mFed2, 1.0)
complete_time = h.helicsFederateRequestTimeComplete(mFed1)
assert granted_time == 1.0
assert complete_time == 1.0
res = h.helicsEndpointPendingMessages(epid2)
assert res == 3
res = h.helicsFederatePendingMessages(mFed2)
assert res == 3
assert h.helicsEndpointGetDefaultDestination(epid1) == "ep2"
# FIXME: Someday this will be implemented.
# @test_broken h.helicsEndpointGetOption(epid1, h.HELICS_HANDLE_OPTION_IGNORE_INTERRUPTS) is True
destroyFederate(mFed1, fedinfo1)
destroyFederate(mFed2, fedinfo2)
destroyBroker(broker)
def test_filter_type_tests_registration():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter2")
h.helicsFilterAddDestinationTarget(f2, "port2")
assert f1 != f2
_ = h.helicsFederateRegisterEndpoint(fFed, "fout", "")
f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"c4")
h.helicsFilterAddSourceTarget(f3, "Testfilter/fout")
f1_b = h.helicsFederateGetFilter(fFed, "filter1")
tmp = h.helicsFilterGetName(f1_b)
assert tmp == "Testfilter/filter1"
f1_c = h.helicsFederateGetFilterByIndex(fFed, 2)
tmp = h.helicsFilterGetName(f1_c)
assert tmp == "Testfilter/c4"
# @test_throws h.HELICSErrorInvalidArgument f1_n = h.helicsFederateGetFilterByIndex(fFed, -2)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_filter_type_tests_info():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
h.helicsEndpointSetInfo(p1, "p1_test")
h.helicsEndpointSetInfo(p2, "p2_test")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
h.helicsFilterSetInfo(f1, "f1_test")
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter2")
h.helicsFilterAddDestinationTarget(f2, "port2")
h.helicsFilterSetInfo(f2, "f2_test")
ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "")
h.helicsEndpointSetInfo(ep1, "ep1_test")
f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"c4")
h.helicsFilterAddSourceTarget(f3, "filter0/fout")
h.helicsFilterSetInfo(f3, "f3_test")
assert h.helicsEndpointGetInfo(p1) == "p1_test"
assert h.helicsEndpointGetInfo(p2) == "p2_test"
assert h.helicsEndpointGetInfo(ep1) == "ep1_test"
assert h.helicsFilterGetInfo(f1) == "f1_test"
assert h.helicsFilterGetInfo(f2) == "f2_test"
assert h.helicsFilterGetInfo(f3) == "f3_test"
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_bad_input_filter_test4():
broker = createBroker(1)
mFed1, fedinfo = createMessageFederate(1, "test")
filt1 = h.helicsFederateRegisterCloningFilter(mFed1, "filt1")
# @test_throws h.HELICSErrorRegistrationFailure
with pt.raises(h.HelicsException):
filt2 = h.helicsFederateRegisterCloningFilter(mFed1, "filt1")
# @test_throws h.HELICSErrorInvalidArgument
with pt.raises(h.HelicsException):
h.helicsFilterSetString(filt1, "unknown", "string")
h.helicsFederateRegisterGlobalEndpoint(mFed1, "ept1", "")
h.helicsFilterAddDeliveryEndpoint(filt1, "ept1")
h.helicsFilterAddSourceTarget(filt1, "ept1")
h.helicsFilterAddDestinationTarget(filt1, "ept1")
h.helicsFilterRemoveTarget(filt1, "ept1")
# @test_throws h.HELICSErrorInvalidArgument
with pt.raises(h.HelicsException):
h.helicsFilterSet(filt1, "unknown", 10.0)
h.helicsFederateFinalize(mFed1)
destroyFederate(mFed1, fedinfo)
destroyBroker(broker)
def test_bad_input_message_federate_message():
broker = createBroker(1)
mFed1, fedinfo = createMessageFederate(1, "test")
ept1 = h.helicsFederateRegisterGlobalEndpoint(mFed1, "ept1", "")
with pt.raises(h.HelicsException):
h.helicsFederateRegisterGlobalEndpoint(mFed1, "ept1", "")
h.helicsFederateEnterExecutingMode(mFed1)
h.helicsEndpointSetDefaultDestination(ept1, "ept1")
mess0 = h.helicsEndpointGetMessage(ept1)
mess0 = h.helicsFederateGetMessage(mFed1)
with pt.raises(h.HelicsException):
h.helicsEndpointSendMessage(ept1, mess0)
h.helicsFederateRequestNextStep(mFed1)
cnt = h.helicsEndpointPendingMessages(ept1)
assert cnt == 0
h.helicsFederateFinalize(mFed1)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsEndpointSendMessage(ept1, mess0)
destroyFederate(mFed1, fedinfo)
destroyBroker(broker)
def test_messagefilter_registration():
broker = createBroker(2)
fFed, ffedinfo = createMessageFederate(1, "filter")
mFed, mfedinfo = createMessageFederate(1, "message")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter2")
h.helicsFederateRegisterEndpoint(fFed, "fout", "")
h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter0/fout")
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
filter_name = h.helicsFilterGetName(f1)
assert filter_name == "Testfilter/filter1"
filter_name = h.helicsFilterGetName(f2)
assert filter_name == "Testfilter/filter2"
# filter_target = h.helicsFilterGetTarget(f2)
# assert filter_target == "port2"
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
destroyFederate(fFed, ffedinfo)
destroyFederate(mFed, mfedinfo)
time.sleep(1.0)
destroyBroker(broker)
def test_bad_input_filter_core_tests():
broker = createBroker(1)
mFed1, fedinfo = createMessageFederate(1, "test")
cr = h.helicsFederateGetCoreObject(mFed1)
filt1 = h.helicsCoreRegisterFilter(cr, h.HELICS_FILTER_TYPE_DELAY, "filt1")
# @test_throws h.HELICSErrorRegistrationFailure
with pt.raises(h.HelicsException):
filt2 = h.helicsCoreRegisterFilter(cr, h.HELICS_FILTER_TYPE_DELAY,
"filt1")
h.helicsFilterSetOption(filt1, h.HELICS_HANDLE_OPTION_CONNECTION_OPTIONAL,
True)
assert h.helicsFilterGetOption(filt1,
h.HELICS_HANDLE_OPTION_CONNECTION_OPTIONAL)
h.helicsFederateFinalize(mFed1)
h.helicsCoreDestroy(cr)
destroyFederate(mFed1, fedinfo)
destroyBroker(broker)
def test_filter_test_types_clone_test_broker_dest_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1.0)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
h.helicsBrokerAddDestinationFilterToEndpoint(broker, "filt1", "dest")
h.helicsBrokerAddDestinationFilterToEndpoint(broker, "", "dest")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
# TODO: figure out why this test fails on CI
# @test_broken False
# assert h.helicsFederateHasMessage(dcFed) is False
# h.helicsFederateRequestTime(dcFed, 2.0)
# assert h.helicsFederateHasMessage(dcFed) is True
# m2 = h.helicsEndpointGetMessage(p3)
# assert h.helicsMessageGetSource(m2) == "src"
# assert h.helicsMessageGetOriginalSource(m2) == "src"
# assert h.helicsMessageGetDestination(m2) == "cm"
# assert h.helicsMessageGetOriginalDestination(m2) == "dest"
# assert h.helicsMessageGetRawDataSize(m2) == len(data)
# _ = h.helicsFederateHasMessage(dcFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_callback_test():
broker = createBroker(2)
assert """helics.HelicsBroker(identifier = "mainbroker", address = "tcp://127.0.0.1:23404")""" in repr(
broker)
fFed, fedinfo1 = createMessageFederate(1, "filter", 1.0)
mFed, fedinfo2 = createMessageFederate(1, "message", 1.0)
h.helicsFederateSetFlagOption(mFed,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
assert (
"""helics.HelicsEndpoint(name = "port1", type = "", info = "", is_valid = True, default_destination = "", n_pending_messages = 0)"""
in repr(p1))
assert (
"""helics.HelicsEndpoint(name = "port2", type = "", info = "", is_valid = True, default_destination = "", n_pending_messages = 0)"""
in repr(p2))
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
f2 = h.helicsFederateRegisterFilter(mFed, h.HELICS_FILTER_TYPE_DELAY,
"dfilter")
h.helicsFilterAddSourceTarget(f1, "port1")
assert 'name = "Testfilter/filter1"' in repr(f1)
userdata = UserData(5)
handle = h.ffi.new_handle(userdata)
h.helicsFilterSetCustomCallback(f1, filterFunc1, handle)
with pt.raises(h.HelicsException):
h.helicsFilterSetCustomCallback(f2, filterFunc1, handle)
assert (
"""helics.HelicsMessageFederate(name = "Testfilter", state = HelicsFederateState.STARTUP, current_time = -9223372036.854776, n_publications = 0, n_subscriptions = 0, n_endpoints = 0, n_filters = 1, n_pending_messages = 0)"""
in repr(fFed))
assert (
"""helics.HelicsMessageFederate(name = "Testmessage", state = HelicsFederateState.STARTUP, current_time = -9223372036.854776, n_publications = 0, n_subscriptions = 0, n_endpoints = 2, n_filters = 1, n_pending_messages = 0)"""
in repr(mFed))
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
assert (
"""helics.HelicsMessageFederate(name = "Testfilter", state = HelicsFederateState.EXECUTION, current_time = 0.0, n_publications = 0, n_subscriptions = 0, n_endpoints = 0, n_filters = 1, n_pending_messages = 0)"""
in repr(fFed))
assert (
"""helics.HelicsMessageFederate(name = "Testmessage", state = HelicsFederateState.EXECUTION, current_time = 0.0, n_publications = 0, n_subscriptions = 0, n_endpoints = 2, n_filters = 1, n_pending_messages = 0)"""
in repr(mFed))
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsFederateHasMessage(mFed) is False
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
h.helicsFederateRequestTimeAsync(fFed, 3.0)
h.helicsFederateRequestTime(mFed, 3.0)
assert h.helicsEndpointHasMessage(p2)
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
h.helicsFederateRequestTime(mFed, 3.0)
h.helicsFederateRequestTimeComplete(fFed)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_filter_test_types_clone_test_dest_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1.0)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 2.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
_ = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
_ = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
cr = h.helicsFederateGetCoreObject(sFed)
h.helicsCoreAddDestinationFilterToEndpoint(cr, "filt1", "dest")
h.helicsCoreAddDestinationFilterToEndpoint(cr, "", "dest")
h.helicsCoreFree(cr)
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
q = h.helicsCreateQuery("", "filtered_endpoints")
filteredEndpoints = h.helicsQueryExecute(q, dFed)
assert "cloningdestFilter" in str(filteredEndpoints)
h.helicsQueryFree(q)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateFinalize(sFed)
# TODO: implement threading
# auto dFedExec = [&]() {
# h.helicsFederateRequestTime(dFed, 1.0)
# m2 = h.helicsEndpointGetMessage(p2)
# h.helicsFederateFinalize(dFed, "")
# }
# h.helics_message m3
# auto dcFedExec = [&]() {
# h.helicsFederateRequestTime(dcFed, 2.0)
# auto res = h.helicsFederateHasMessage(dcFed)
# if (res == h.helics_False) {
# std::this_thread::sleep_for(std::chrono::milliseconds(50))
# h.helicsFederateRequestTime(dcFed, 4.0)
# }
# m3 = h.helicsEndpointGetMessage(p3)
# h.helicsFederateFinalize(dcFed)
# }
# auto threaddFed = std::thread(dFedExec)
# auto threaddcFed = std::thread(dcFedExec)
# threaddFed.join()
# (m2.source, "src")
# (m2.original_source, "src")
# (m2.dest, "dest")
# (m2.length, static_cast<int64_t>(data.size()))
# threaddcFed.join()
# (m3.source, "src")
# (m3.original_source, "src")
# (m3.dest, "cm")
# (m3.original_dest, "dest")
# (m3.length, static_cast<int64_t>(data.size()))
# (state = h.helicsFederateGetState(sFed))
# (state == h.helics_state_finalize)
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_test_types_clone_test_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(
1,
"source",
1.0,
)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
cr = h.helicsFederateGetCoreObject(sFed)
h.helicsCoreAddSourceFilterToEndpoint(cr, "filt1", "src")
h.helicsCoreAddSourceFilterToEndpoint(cr, "", "src")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
q = h.helicsCreateQuery("", "filtered_endpoints")
filteredEndpoints = h.helicsQueryExecute(q, sFed)
assert "srcFilters" in str(filteredEndpoints)
assert "(cloning)" in str(filteredEndpoints)
h.helicsQueryFree(q)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsFederateHasMessage(dcFed) is True
m2 = h.helicsEndpointGetMessage(p3)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "cm"
assert h.helicsMessageGetOriginalDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_test_types_clone_test():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterCloningFilter(dcFed, "")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
h.helicsFilterAddSourceTarget(f1, "src")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
state = h.helicsFederateGetState(dcFed)
assert state == h.HELICS_STATE_EXECUTION
state = h.helicsFederateGetState(dFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed)
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsFederateHasMessage(dcFed)
m2 = h.helicsEndpointGetMessage(p3)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "cm"
assert h.helicsMessageGetOriginalDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_test_types_message_filter_function3():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter", 1)
mFed, fedinfo2 = createMessageFederate(1, "message", 1)
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random")
f1 = h.helicsFederateRegisterGlobalFilter(fFed,
h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port1")
h.helicsFederateRegisterEndpoint(fFed, "fout", "")
f3 = h.helicsFederateRegisterFilter(fFed,
h.HELICS_FILTER_TYPE_RANDOM_DELAY,
"filter3")
h.helicsFilterAddSourceTarget(f3, "filter0/fout")
h.helicsFilterSet(f2, "delay", 2.5)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "hello world".encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsFederateHasMessage(mFed) is False
h.helicsEndpointSendMessageRaw(p2, "port1", data)
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
# there may be something wrong here yet but this test isn't the one to find it and
# this may prevent spurious errors for now.
# std::this_thread::yield()
h.helicsFederateRequestTimeAsync(mFed, 3.0)
h.helicsFederateRequestTime(fFed, 3.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2)
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
assert h.helicsEndpointHasMessage(p1) is True
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(mFed, fedinfo1)
destroyFederate(fFed, fedinfo2)
destroyBroker(broker)
def test_filter_test_types_function2():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
h.helicsFilterSet(f1, "delay", 2.5)
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port2")
h.helicsFilterSet(f2, "delay", 2.5)
# this is expected to fail since a regular filter doesn't have a delivery endpoint
# @test_throws h.HELICSErrorInvalidObject h.helicsFilterAddDeliveryEndpoint(f2, "port1")
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
res = h.helicsFederateHasMessage(mFed)
assert res is False
h.helicsEndpointSendMessageRaw(p2, "port1", data)
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
# there may be something wrong here yet but this test isn't the one to find it and
# this may prevent spurious errors for now.
# std::this_thread::yield()
h.helicsFederateRequestTime(mFed, 3.0)
assert h.helicsEndpointHasMessage(p2) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
assert h.helicsEndpointHasMessage(p1) is False
h.helicsFederateRequestTime(mFed, 4.0)
assert h.helicsEndpointHasMessage(p1) is True
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_messagefederate_timing_tests():
broker = createBroker(1)
vFed1, fedinfo1 = createMessageFederate(1, "fed0")
vFed2, fedinfo2 = createMessageFederate(1, "fed1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 0.1)
h.helicsFederateSetTimeProperty(vFed2, h.HELICS_PROPERTY_TIME_PERIOD, 0.1)
h.helicsFederateSetTimeProperty(vFed2, h.HELICS_PROPERTY_TIME_INPUT_DELAY,
0.1)
h.helicsFederateSetFlagOption(vFed1,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
h.helicsFederateSetFlagOption(vFed2,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
ept1 = h.helicsFederateRegisterGlobalEndpoint(vFed1, "e1", "")
h.helicsFederateRegisterGlobalEndpoint(vFed2, "e2", "")
h.helicsFederateEnterExecutingModeAsync(vFed1)
h.helicsFederateEnterExecutingMode(vFed2)
h.helicsFederateEnterExecutingModeComplete(vFed1)
h.helicsFederateRequestTimeAsync(vFed2, 2.0)
gtime = h.helicsFederateRequestTime(vFed1, 1.0)
# check that the request is only granted at the appropriate period
assert gtime == 1.0
assert h.helicsFederateGetIntegerProperty(
vFed1, h.HELICS_PROPERTY_INT_CONSOLE_LOG_LEVEL) == -1
assert h.helicsFederateGetIntegerProperty(
vFed2, h.HELICS_PROPERTY_INT_CONSOLE_LOG_LEVEL) == -1
assert h.helicsFederateGetFlagOption(
vFed1, h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS) is True
assert h.helicsFederateGetFlagOption(
vFed2, h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS) is True
h.helicsEndpointSendMessageRaw(ept1, "e2", "test1".encode())
h.helicsFederateRequestTimeAsync(vFed1, 1.9)
gtime = h.helicsFederateRequestTimeComplete(vFed2)
assert gtime >= 1.1 # the message should show up at the next available time point after the impact window
h.helicsFederateRequestTimeAsync(vFed2, 2.0)
gtime = h.helicsFederateRequestTimeComplete(vFed1)
assert gtime >= 1.9
tres = h.helicsFederateGetTimeProperty(vFed1,
h.HELICS_PROPERTY_TIME_PERIOD)
assert tres == 0.1
# m = h.helicsEndpointGetMessage(ept1)
# @show h.helicsMessageGetRawData(m)
# TODO: null pointer received from C
gtime = h.helicsFederateRequestTimeComplete(vFed2)
assert gtime == 2.0
h.helicsFederateFinalize(vFed1)
h.helicsFederateFinalize(vFed2)
destroyFederate(vFed1, fedinfo1)
destroyFederate(vFed2, fedinfo2)
destroyBroker(broker)
