def test_message_federate_initialize(mFed):
state = h.helicsFederateGetState(mFed)
assert state == 0
h.helicsFederateEnterExecutingMode(mFed)
state = h.helicsFederateGetState(mFed)
assert state == 2
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_value_federate_initialize(vFed):
status, state = h.helicsFederateGetState(vFed)
assert state == 0
h.helicsFederateEnterExecutionMode(vFed)
status, state = h.helicsFederateGetState(vFed)
assert state == 2
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_valuefederate_state():
broker = createBroker()
vFed, fedinfo = createValueFederate()
state = h.helicsFederateGetState(vFed)
assert state == 0
h.helicsFederateEnterExecutingMode(vFed)
state = h.helicsFederateGetState(vFed)
assert state == 2
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def FreeFederate(fed):
status = h.helicsFederateFinalize(fed)
status, state = h.helicsFederateGetState(fed)
assert state == 3
h.helicsFederateFree(fed)
def test_messagefederate_test_message_federate_endpoint_registration(mFed):
epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", "")
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random")
h.helicsFederateEnterExecutingMode(mFed)
assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed)
endpoint_name = h.helicsEndpointGetName(epid1)
assert endpoint_name == "TestA Federate/ep1"
endpoint_name = h.helicsEndpointGetName(epid2)
assert endpoint_name == "ep2"
endpoint_name = h.helicsEndpointGetType(epid1)
assert endpoint_name == ""
endpoint_name = h.helicsEndpointGetType(epid2)
assert endpoint_name == "random"
epid_b = h.helicsFederateGetEndpoint(mFed, "ep2")
type = h.helicsEndpointGetType(epid_b)
assert type == "random"
epid_c = h.helicsFederateGetEndpointByIndex(mFed, 0)
name = h.helicsEndpointGetName(epid_c)
assert name == "TestA Federate/ep1"
def FreeFederate(fed, fedinfo):
h.helicsFederateFinalize(fed)
state = h.helicsFederateGetState(fed)
assert state == 3 # TODO: should this be 3?
h.helicsFederateInfoFree(fedinfo)
h.helicsFederateFree(fed)
def test_value_federate_runFederateTimeoutTest(helicsBroker):
fedinitstring = "--broker=mainbroker --federates=1"
deltat = 0.01
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, "TestA Core")
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.helics_property_int_log_level, 1)
vFed = h.helicsCreateValueFederate("TestA Federate", fedinfo)
defaultValue = "String1"
testValue = "String2"
pubid = h.helicsFederateRegisterGlobalPublication(
vFed, "pub1", h.helics_data_type_string, "")
subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "")
h.helicsInputSetDefaultString(subid, defaultValue)
h.helicsFederateEnterExecutingMode(vFed)
counter = 60
while counter > 0:
counter -= 1
time.sleep(1)
# Broker should be connected at this point
assert h.helicsBrokerIsConnected(
helicsBroker) == 1, "Broker should still be connected"
h.helicsFederateFinalize(vFed)
state = h.helicsFederateGetState(vFed)
assert state == 3
while (h.helicsBrokerIsConnected(helicsBroker)):
time.sleep(1)
h.helicsFederateInfoFree(fedinfo)
h.helicsFederateFree(vFed)
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 destroy_value_federate(fed):
h.helicsFederateFinalize(fed)
state = h.helicsFederateGetState(fed)
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def destroy_federate(fed, broker=None):
status = h.helicsFederateFinalize(fed)
state = h.helicsFederateGetState(fed)
assert state == 3
while (h.helicsBrokerIsConnected(broker)):
time.sleep(1)
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def destroy_value_federate(fed):
status = h.helicsFederateFinalize(fed)
status, state = h.helicsFederateGetState(fed)
assert state == 3
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def test_message_filter_function(broker):
fFed, ffedinfo = AddFederate(broker, "zmq", 1, 1, "filter")
mFed, mfedinfo = AddFederate(broker, "zmq", 1, 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)
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")
FreeFederate(fFed, ffedinfo)
FreeFederate(mFed, mfedinfo)
time.sleep(1.0)
def test_messagefederate_message_object_tests(mFed):
epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", "")
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random")
h.helicsFederateSetTimeProperty(mFed, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateEnterExecutingMode(mFed)
assert h.helicsFederateGetState(mFed) == h.HELICS_STATE_EXECUTION
msg = h.helicsFederateCreateMessage(mFed)
h.helicsMessageSetDestination(msg, "ep2")
h.helicsMessageGetDestination(msg) == "ep2"
h.helicsMessageSetData(msg, "".join(["a" for _ in range(0, 500)]).encode())
h.helicsMessageSetTime(msg, 0.0)
h.helicsEndpointSendMessage(epid1, msg)
t = h.helicsFederateRequestTime(mFed, 1.0)
assert t == 1.0
assert h.helicsFederateHasMessage(mFed) is True
assert h.helicsEndpointHasMessage(epid1) is False
assert h.helicsEndpointHasMessage(epid2) is True
msg = h.helicsEndpointGetMessage(epid2)
assert h.helicsMessageGetRawDataSize(msg) == 500
# TODO: segfaults
# print(h.helicsMessageGetRawData(msg))
# @test_broken False
# segfaults
# rawdata = h.helicsMessageGetRawDataPointer(msg)
# assert Char(unsafe_load(Ptr{Cchar}(rdata), 245)) == 'a'
h.helicsFederateFinalize(mFed)
assert h.helicsFederateGetState(mFed) == h.HELICS_STATE_FINALIZE
h.helicsMessageSetFlagOption(msg, 7, True)
assert h.helicsMessageCheckFlag(msg, 7) is True
h.helicsMessageClearFlags(msg)
assert h.helicsMessageCheckFlag(msg, 7) is False
h.helicsEndpointSetDefaultDestination(epid1, "ep2")
def destroyFederate(fed, fedinfo, broker=None):
h.helicsFederateFinalize(fed)
_ = h.helicsFederateGetState(fed)
if broker is not None:
while h.helicsBrokerIsConnected(broker):
time.sleep(1)
h.helicsFederateInfoFree(fedinfo)
h.helicsFederateFree(fed)
if broker is not None:
destroyBroker(broker)
def vFed():
initstring = "-f 1 --name=mainbroker"
fedinitstring = "--broker=mainbroker --federates=1"
deltat = 0.01
#TODO: should add an assert here about helicsGetVersion
h.helicsGetVersion()
# Create broker #
broker = h.helicsCreateBroker("zmq", "", initstring)
isconnected = h.helicsBrokerIsConnected(broker)
if isconnected == 1:
pass
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, "TestA Core")
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.helics_property_int_log_level, 1)
vFed = h.helicsCreateValueFederate("TestA Federate", fedinfo)
yield vFed
h.helicsFederateFinalize(vFed)
state = h.helicsFederateGetState(vFed)
assert state == 3
while (h.helicsBrokerIsConnected(broker)):
time.sleep(1)
h.helicsFederateInfoFree(fedinfo)
h.helicsFederateFree(vFed)
h.helicsCloseLibrary()
def destroy_value_federate(fed, broker):
h.helicsFederateFinalize(fed)
state = h.helicsFederateGetState(fed)
while h.helicsBrokerIsConnected(broker):
time.sleep(1)
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def mFed():
import helics as h
initstring = "1 --name=mainbroker"
fedinitstring = "--broker=mainbroker --federates=1"
deltat = 0.01
helicsversion = h.helicsGetVersion()
# Create broker #
broker = h.helicsCreateBroker("zmq", "", initstring)
isconnected = h.helicsBrokerIsConnected(broker)
if isconnected == 1:
pass
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsFederateInfoCreate()
# Set Federate name #
status = h.helicsFederateInfoSetFederateName(fedinfo, "TestA Federate")
# Set core type from string #
status = h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
status = h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
status = h.helicsFederateInfoSetTimeDelta(fedinfo, deltat)
status = h.helicsFederateInfoSetLoggingLevel(fedinfo, 1)
mFed = h.helicsCreateMessageFederate(fedinfo)
yield mFed
status = h.helicsFederateFinalize(mFed)
status, state = h.helicsFederateGetState(mFed)
assert state == 3
while (h.helicsBrokerIsConnected(broker)):
time.sleep(1)
h.helicsFederateFree(mFed)
h.helicsCloseLibrary()
def mFed():
initstring = "-f 1 --name=mainbroker"
fedinitstring = "--broker=mainbroker --federates=1"
deltat = 0.01
h.helicsGetVersion()
# Create broker #
broker = h.helicsCreateBroker("zmq", "", initstring)
isconnected = h.helicsBrokerIsConnected(broker)
if isconnected == 1:
pass
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, "CoreA Federate")
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.HELICS_PROPERTY_TIME_DELTA,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.HELICS_PROPERTY_INT_LOG_LEVEL, 1)
mFed = h.helicsCreateMessageFederate("TestA Federate", fedinfo)
yield mFed
h.helicsFederateFinalize(mFed)
state = h.helicsFederateGetState(mFed)
assert state == 3
while h.helicsBrokerIsConnected(broker):
time.sleep(1)
h.helicsFederateInfoFree(fedinfo)
h.helicsFederateFree(mFed)
h.helicsCloseLibrary()
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_message_filter_function(broker):
fFed = AddFederate(broker, "zmq", 1, 1, "filter")
mFed = AddFederate(broker, "zmq", 1, 1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_delay_filter,
"port1", "filter1")
status = h.helicsFilterSet(f1, "delay", 2.5)
assert status == 0
status = h.helicsFederateEnterExecutionModeAsync(fFed)
assert status == 0
status = h.helicsFederateEnterExecutionMode(mFed)
assert status == 0
status = h.helicsFederateEnterExecutionModeComplete(fFed)
assert status == 0
status, state = h.helicsFederateGetState(fFed)
assert status == 0
assert state == 2
data = "hello world"
h.helicsEndpointSendMessageRaw(p1, "port2", data)
grantedtime = h.helicsFederateRequestTimeAsync(mFed, 1.0)
assert grantedtime == 0
status, grantedtime = h.helicsFederateRequestTime(fFed, 1.0)
assert status == 0
assert grantedtime == 1.0
status, grantedtime = h.helicsFederateRequestTimeComplete(mFed)
assert status == 0
assert grantedtime == 1.0
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")
FreeFederate(fFed)
FreeFederate(mFed)
time.sleep(1.0)
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 __del__(self):
helics.helicsFederateFinalize(self._PyDSSfederate)
state = helics.helicsFederateGetState(self._PyDSSfederate)
helics.helicsFederateInfoFree(self.fedinfo)
helics.helicsFederateFree(self._PyDSSfederate)
self._logger.info('HELICS federate for PyDSS destroyed')
