def test_valuefederate_test_string():
broker = createBroker()
vFed, fedinfo = createValueFederate()
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)
h.helicsPublicationPublishString(pubid, testValue)
value = h.helicsInputGetString(subid)
assert value == defaultValue
grantedtime = h.helicsFederateRequestTime(vFed, 1.0)
assert grantedtime == 0.01
value = h.helicsInputGetString(subid)
assert value == testValue
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_valuefederate_test_complex():
broker = createBroker()
vFed, fedinfo = createValueFederate()
rDefaultValue = 1.0
iDefaultValue = 1.0
rTestValue = 2.0
iTestValue = 2.0
pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_COMPLEX, "")
subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "")
h.helicsInputSetDefaultComplex(subid, complex(rDefaultValue, iDefaultValue))
h.helicsFederateEnterExecutingMode(vFed)
# publish string1 at time=0.0
h.helicsPublicationPublishComplex(pubid, complex(rTestValue, iTestValue))
assert (rDefaultValue, iDefaultValue) == h.helicsInputGetComplex(subid)
grantedtime = h.helicsFederateRequestTime(vFed, 1.0)
assert grantedtime == 0.01
assert (rTestValue, iTestValue) == h.helicsInputGetComplex(subid)
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_valuefederate_test_integer():
broker = createBroker()
vFed, fedinfo = createValueFederate()
defaultValue = 1
testValue = 2
pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_INT, "")
subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "")
h.helicsInputSetDefaultInteger(subid, defaultValue)
h.helicsFederateEnterExecutingMode(vFed)
h.helicsPublicationPublishInteger(pubid, testValue)
value = h.helicsInputGetInteger(subid)
assert value == defaultValue
grantedtime = h.helicsFederateRequestTime(vFed, 1.0)
assert grantedtime == 0.01
value = h.helicsInputGetInteger(subid)
assert value == testValue
h.helicsPublicationPublishInteger(pubid, testValue + 1)
grantedtime = h.helicsFederateRequestTime(vFed, 2.0)
assert grantedtime == 0.02
value = h.helicsInputGetInteger(subid)
assert value == testValue + 1
destroyFederate(vFed, fedinfo)
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_valuefederate_publisher_registration():
broker = createBroker()
vFed, fedinfo = createValueFederate()
pubid1 = h.helicsFederateRegisterPublication(vFed, "pub1", h.HELICS_DATA_TYPE_STRING, "")
pubid2 = h.helicsFederateRegisterGlobalPublication(vFed, "pub2", h.HELICS_DATA_TYPE_INT, "")
pubid3 = h.helicsFederateRegisterPublication(vFed, "pub3", h.HELICS_DATA_TYPE_DOUBLE, "V")
h.helicsFederateEnterExecutingMode(vFed)
publication_key = h.helicsPublicationGetKey(pubid1)
assert publication_key == "TestA Federate/pub1"
publication_type = h.helicsPublicationGetType(pubid1)
assert publication_type == "string"
publication_key = h.helicsPublicationGetKey(pubid2)
assert publication_key == "pub2"
publication_key = h.helicsPublicationGetKey(pubid3)
assert publication_key == "TestA Federate/pub3"
publication_type = h.helicsPublicationGetType(pubid3)
assert publication_type == "double"
publication_units = h.helicsPublicationGetUnits(pubid3)
assert publication_units == "V"
publication_type = h.helicsPublicationGetType(pubid2)
assert publication_type == "int64"
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
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_bad_input_tests_raw_tests():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "test")
pubid = h.helicsFederateRegisterPublication(vFed1, "pub1",
h.HELICS_DATA_TYPE_RAW, "")
subid = h.helicsFederateRegisterGlobalInput(vFed1, "inp1",
h.HELICS_DATA_TYPE_RAW, "")
h.helicsPublicationAddTarget(pubid, "inp1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
h.helicsFederateEnterExecutingMode(vFed1)
h.helicsPublicationPublishRaw(pubid, b"hello world")
h.helicsFederateRequestNextStep(vFed1)
s = h.helicsInputGetRawValue(subid)
assert s == b"hello world"
h.helicsPublicationPublishDouble(pubid, 27)
h.helicsFederateRequestNextStep(vFed1)
s = h.helicsInputGetComplex(subid)
assert complex(*s) != 27 + 0j
h.helicsFederateFinalize(vFed1)
t, res = h.helicsFederateRequestTimeIterative(
vFed1, 1.0, h.HELICS_ITERATION_REQUEST_NO_ITERATION)
assert res == h.HELICS_ITERATION_RESULT_HALTED
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
def test_valuefederate_test_vectord():
broker = createBroker()
vFed, fedinfo = createValueFederate()
defaultValue = [0.0, 1.0, 2.0]
testValue = [3.0, 4.0, 5.0]
pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_VECTOR, "")
subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "")
h.helicsInputSetDefaultVector(subid, defaultValue)
h.helicsFederateEnterExecutingMode(vFed)
h.helicsPublicationPublishVector(pubid, testValue)
assert h.helicsInputGetVector(subid) == defaultValue
grantedtime = h.helicsFederateRequestTime(vFed, 1.0)
assert grantedtime == 0.01
value = h.helicsInputGetVector(subid)
assert value == testValue
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_query_broker_tests():
broker = createBroker(2)
vFed1, fedinfo1 = createValueFederate(1, "fed0")
vFed2, fedinfo2 = createValueFederate(1, "fed1")
core = h.helicsFederateGetCoreObject(vFed1)
q1 = h.helicsCreateQuery("root", "federates")
res = h.helicsQueryCoreExecute(q1, core)
name1 = h.helicsFederateGetName(vFed1)
name2 = h.helicsFederateGetName(vFed2)
try:
assert f"[{name1};{name2}]" == res
except AssertionError:
assert [name1, name2] == res
res = h.helicsQueryExecute(q1, vFed1)
try:
assert f"[{name1};{name2}]" == res
except AssertionError:
assert [name1, name2] == res
h.helicsFederateEnterInitializingModeAsync(vFed1)
h.helicsFederateEnterInitializingMode(vFed2)
h.helicsFederateEnterInitializingModeComplete(vFed1)
h.helicsQueryFree(q1)
h.helicsCoreFree(core)
h.helicsFederateFinalizeAsync(vFed1)
h.helicsFederateFinalize(vFed2)
h.helicsFederateFinalizeComplete(vFed1)
destroyFederate(vFed1, fedinfo1)
destroyFederate(vFed2, fedinfo2)
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_iteration_execution_iteration_test():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
pubid = h.helicsFederateRegisterGlobalPublication(
vFed1, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "")
subid = h.helicsFederateRegisterSubscription(vFed1, "pub1", "")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateEnterInitializingMode(vFed1)
h.helicsPublicationPublishDouble(pubid, 27.0)
comp = h.helicsFederateEnterExecutingModeIterative(
vFed1, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
assert comp == h.HELICS_ITERATION_RESULT_ITERATING
val = h.helicsInputGetDouble(subid)
assert val == 27.0
comp = h.helicsFederateEnterExecutingModeIterative(
vFed1, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
assert comp == h.HELICS_ITERATION_RESULT_NEXT_STEP
val2 = h.helicsInputGetDouble(subid)
assert val2 == val
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
def test_valuefederate_test_info_filed():
broker = createBroker()
vFed, fedinfo = createValueFederate(1, "fed0")
h.helicsFederateSetFlagOption(vFed, h.HELICS_HANDLE_OPTION_CONNECTION_OPTIONAL, True)
# register the publications/subscriptions
subid1 = h.helicsFederateRegisterSubscription(vFed, "sub1", "")
pubid1 = h.helicsFederateRegisterTypePublication(vFed, "pub1", "string", "")
pubid2 = h.helicsFederateRegisterGlobalTypePublication(vFed, "pub2", "string", "")
# Set info fields
h.helicsInputSetInfo(subid1, "sub1_test")
h.helicsPublicationSetInfo(pubid1, "pub1_test")
h.helicsPublicationSetInfo(pubid2, "pub2_test")
h.helicsFederateEnterExecutingMode(vFed)
assert h.helicsInputGetInfo(subid1) == "sub1_test"
assert h.helicsPublicationGetInfo(pubid1) == "pub1_test"
assert h.helicsPublicationGetInfo(pubid2) == "pub2_test"
cr = h.helicsFederateGetCoreObject(vFed)
h.helicsFederateFinalize(vFed)
wait = h.helicsCoreWaitForDisconnect(cr, 70)
if wait is False:
wait = h.helicsCoreWaitForDisconnect(cr, 500)
assert wait is True
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_valuefederate_test_single_transfer():
broker = createBroker()
vFed, fedinfo = createValueFederate()
s = "n2"
pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_STRING, "")
subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "")
h.helicsFederateEnterExecutingMode(vFed)
h.helicsPublicationPublishString(pubid, "string1")
grantedtime = h.helicsFederateRequestTime(vFed, 1.0)
assert grantedtime == 0.01
s = h.helicsInputGetString(subid)
assert s == "string1"
t = h.helicsInputLastUpdateTime(subid)
assert t == 0.01
h.helicsPublicationPublishString(pubid, "string2")
destroyFederate(vFed, fedinfo)
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_broker():
broker = createBroker(1)
initstring = "--broker="
identifier = h.helicsBrokerGetIdentifier(broker)
initstring = initstring + identifier
initstring = initstring + " --broker_address "
address = h.helicsBrokerGetAddress(broker)
initstring = initstring + address
assert initstring == "--broker=mainbroker --broker_address tcp://127.0.0.1:23404"
destroyBroker(broker)
def test_bad_input_init_error():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
# the types here don't match which causes an error when initializing the federation
h.helicsFederateRegisterGlobalTypePublication(vFed1, "pub1", "custom1", "")
subid = h.helicsFederateRegisterTypeInput(vFed1, "inp1", "custom2", "")
k1 = h.helicsInputGetKey(subid)
# check some other calls
inp2 = h.helicsFederateGetInput(vFed1, "inp1")
k2 = h.helicsInputGetKey(inp2)
assert k1 == k2
inp3 = h.helicsFederateGetInputByIndex(vFed1, 0)
k3 = h.helicsInputGetKey(inp3)
assert k1 == k3
h.helicsInputAddTarget(subid, "pub1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
# unknown publication
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidArgument
pub3 = h.helicsFederateGetPublication(vFed1, "unknown")
# error in this call from the mismatch
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorConnectionFailure
h.helicsFederateEnterInitializingMode(vFed1)
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidFunctionCall
h.helicsFederateRequestTimeAdvance(vFed1, 0.1)
# unknown input
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidArgument
inp4 = h.helicsFederateGetInput(vFed1, "unknown")
# invalid input index
# TODO: does this test segfault some times?
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidArgument
inp5 = h.helicsFederateGetInputByIndex(vFed1, 4)
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
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_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 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_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_valuefederate_test_bool():
broker = createBroker()
vFed, fedinfo = createValueFederate()
defaultValue = True
testValue1 = True
testValue2 = False
# register the publications
pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_BOOLEAN, "")
subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "")
h.helicsInputSetDefaultBoolean(subid, defaultValue)
h.helicsFederateEnterExecutingMode(vFed)
# publish string1 at time=0.0
h.helicsPublicationPublishBoolean(pubid, testValue1)
val = h.helicsInputGetBoolean(subid)
assert val == defaultValue
grantedtime = h.helicsFederateRequestTime(vFed, 1.0)
assert grantedtime == 0.01
# get the value
val = h.helicsInputGetBoolean(subid)
# make sure the string is what we expect
assert val == testValue1
# publish a second string
h.helicsPublicationPublishBoolean(pubid, testValue2)
# make sure the value is still what we expect
val = h.helicsInputGetBoolean(subid)
assert val == testValue1
# advance time
grantedtime = h.helicsFederateRequestTime(vFed, 2.0)
# make sure the value was updated
assert grantedtime == 0.02
val = h.helicsInputGetBoolean(subid)
assert val == testValue2
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_valuefederate_named_point():
broker = createBroker()
vFed, fedinfo = createValueFederate()
defaultValue = "start of a longer string in place of the shorter one and now this should be very long"
defVal = 5.3
# testValue1 = "inside of the functional relationship of helics"
testValue1 = "short string"
testVal1 = 45.7823
testValue2 = "I am a string"
testVal2 = 0.0
pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_NAMED_POINT, "")
subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "")
h.helicsInputSetDefaultNamedPoint(subid, defaultValue, defVal)
h.helicsFederateEnterExecutingMode(vFed)
# publish string1 at time=0.0
h.helicsPublicationPublishNamedPoint(pubid, testValue1, testVal1)
assert h.helicsInputGetNamedPoint(subid) == (defaultValue, defVal)
assert h.helicsFederateRequestTime(vFed, 1.0) == 0.01
# # get the value
assert h.helicsInputGetNamedPoint(subid) == (testValue1, testVal1)
# publish a second string
h.helicsPublicationPublishNamedPoint(pubid, testValue2, testVal2)
# # make sure the value is still what we expect
assert h.helicsInputGetNamedPoint(subid) == (testValue1, testVal1)
# # make sure the string is what we expect
# # assert value3 == testValue1
# assert val3 == [testValue1, testVal1]
# # advance time
assert h.helicsFederateRequestTime(vFed, 2.0) == 0.02
# # make sure the value was updated
assert h.helicsInputGetNamedPoint(subid) == (testValue2, testVal2)
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_query_federate_tests():
broker = createBroker(2)
vFed1, fedinfo1 = createValueFederate(1, "fed0")
vFed2, fedinfo2 = createValueFederate(1, "fed1")
h.helicsFederateRegisterGlobalTypePublication(vFed1, "pub1", "double", "")
h.helicsFederateRegisterTypePublication(vFed1, "pub2", "double", "")
h.helicsFederateRegisterTypePublication(vFed2, "pub3", "double", "")
h.helicsFederateEnterInitializingModeAsync(vFed1)
h.helicsFederateEnterInitializingMode(vFed2)
h.helicsFederateEnterInitializingModeComplete(vFed1)
core = h.helicsFederateGetCoreObject(vFed1)
q1 = h.helicsCreateQuery("Testfed0", "publications")
res = h.helicsQueryCoreExecute(q1, core)
try:
assert res == "[pub1;Testfed0/pub2]"
except:
assert res == ["pub1", "Testfed0/pub2"]
# res = h.helicsQueryExecute(q1, vFed2)
# assert res == "[pub1;Testfed0/pub2]"
h.helicsQueryFree(q1)
# q1 = h.helicsCreateQuery("Testfed1", "isinit")
# res = h.helicsQueryExecute(q1, vFed1)
# assert res, "True"
# h.helicsQueryFree(q1)
# q1 = h.helicsCreateQuery("Testfed1", "publications")
# res = h.helicsQueryExecute(q1, vFed1)
# assert res == "[Testfed1/pub3]"
# h.helicsQueryFree(q1)
h.helicsCoreFree(core)
h.helicsFederateFinalizeAsync(vFed1)
h.helicsFederateFinalize(vFed2)
h.helicsFederateFinalizeComplete(vFed1)
destroyFederate(vFed1, fedinfo1)
destroyFederate(vFed2, fedinfo2)
destroyBroker(broker)
def test_bad_inputs_frees():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
fi = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetBroker(fi, "broker test")
h.helicsFederateEnterInitializingMode(vFed1)
h.helicsFederateFinalize(vFed1)
h.helicsFederateInfoSetBrokerPort(fi, 8929)
h.helicsFederateInfoSetLocalPort(fi, "8229")
h.helicsFederateInfoFree(fi)
h.helicsFederateFree(vFed1)
# @test_throws h.HELICSErrorInvalidObject
with pt.raises(h.HelicsException):
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
def test_valuefederate_publication_registration():
broker = createBroker()
vFed, fedinfo = createValueFederate()
pubid1 = h.helicsFederateRegisterTypePublication(vFed, "pub1", "string", "")
pubid2 = h.helicsFederateRegisterGlobalTypePublication(vFed, "pub2", "int", "")
pubid3 = h.helicsFederateRegisterTypePublication(vFed, "pub3", "double", "V")
h.helicsFederateEnterExecutingMode(vFed)
assert h.helicsPublicationGetKey(pubid1) == "TestA Federate/pub1"
assert h.helicsPublicationGetKey(pubid2) == "pub2"
assert h.helicsPublicationGetKey(pubid3) == "TestA Federate/pub3"
assert h.helicsPublicationGetType(pubid3) == "double"
assert h.helicsPublicationGetUnits(pubid3) == "V"
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_bad_input_duplicate_publication_and_input_pathways():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
pubid = h.helicsFederateRegisterTypePublication(vFed1, "pub1", "string",
"")
# @test_throws h.HELICSErrorRegistrationFailure
with pt.raises(h.HelicsException):
pubid2 = h.helicsFederateRegisterTypePublication(
vFed1, "pub1", "string", "")
subid = h.helicsFederateRegisterGlobalTypeInput(vFed1, "inp1", "string",
"")
# @test_throws h.HELICSErrorRegistrationFailure
with pt.raises(h.HelicsException):
subid2 = h.helicsFederateRegisterGlobalTypeInput(
vFed1, "inp1", "string", "")
# @test_throws h.HELICSErrorInvalidObject ept = h.helicsFederateRegisterEndpoint(vFed1, "ept1", "")
h.helicsInputAddTarget(subid, "Testfed0/pub1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
h.helicsFederateEnterExecutingMode(vFed1)
h.helicsPublicationPublishDouble(pubid, 27.0)
h.helicsFederateRequestNextStep(vFed1)
str = h.helicsInputGetString(subid)
assert str[0] == "2"
assert str[1] == "7"
messages = h.helicsFederatePendingMessages(vFed1)
assert messages == 0
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
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_bad_inputs_core_link():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
h.helicsFederateRegisterGlobalTypePublication(vFed1, "pub1", "custom1", "")
h.helicsFederateRegisterTypeInput(vFed1, "inp1", "custom2", "")
fed2 = h.helicsGetFederateByName(h.helicsFederateGetName(vFed1))
assert h.helicsFederateGetName(fed2) == h.helicsFederateGetName(vFed1)
# @test_throws h.HELICSErrorInvalidArgument
with pt.raises(h.HelicsException):
fed3 = h.helicsGetFederateByName("fed_unknown")
cr = h.helicsFederateGetCoreObject(vFed1)
h.helicsCoreDataLink(cr, "pub1", "fed0/inp1")
# @test_throws h.HELICSErrorInvalidArgument
with pt.raises(h.HelicsException):
h.helicsCoreMakeConnections(cr, "unknownfile.json")
# TODO: This test should throw an error
# @test_throws h.HELICSErrorInvalidArgument h.helicsCoreDataLink(cr, "pub1", "")
# @test_broken False
cr2 = h.helicsCoreClone(cr)
assert h.helicsCoreGetAddress(cr2) == h.helicsCoreGetAddress(cr)
# TODO: this should error as well
# h.helicsFederateEnterExecutingMode(vFed1)
# @test_broken False
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, 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)
