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_valuefederate_single_transfer():
broker = createBroker()
vFed, fedinfo = createValueFederate()
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"
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)
def test_bad_inputs_init_error_5():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
h.helicsFederateInfoSetSeparator(fedinfo, "-")
h.helicsFederateSetSeparator(vFed1, "-")
h.helicsFederateRegisterGlobalTypePublication(vFed1, "pub1", "custom1", "")
subid = h.helicsFederateRegisterTypeInput(vFed1, "inp1", "custom2", "")
h.helicsInputAddTarget(subid, "pub1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
# @test_throws h.HELICSErrorConnectionFailure
with pt.raises(h.HelicsException):
resIt = h.helicsFederateEnterExecutingModeIterative(
vFed1, h.HELICS_ITERATION_REQUEST_NO_ITERATION)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsFederateRequestTimeIterativeAsync(
vFed1, 1.0, h.HELICS_ITERATION_REQUEST_NO_ITERATION)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
res = h.helicsFederateRequestTimeIterativeComplete(vFed1)
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
def test_bad_inputs_broker_link():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
h.helicsFederateRegisterGlobalTypePublication(vFed1, "pub1", "custom1", "")
h.helicsFederateRegisterTypeInput(vFed1, "inp1", "custom2", "")
br = h.helicsBrokerClone(broker)
h.helicsBrokerDataLink(br, "pub1", "Testfed0/inp1")
# TODO: This test should throw an error
# @test_throws h.HELICSErrorInvalidArgument
# with pt.raises(h.HelicsException):
# h.helicsBrokerDataLink(br, "pub1", "")
# @test_broken False
# @test_throws h.HELICSErrorInvalidArgument
with pt.raises(h.HelicsException):
h.helicsBrokerMakeConnections(br, "unknownfile.json")
# @test_throws h.HELICSErrorConnectionFailure
with pt.raises(h.HelicsException):
h.helicsFederateEnterExecutingMode(vFed1)
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
h.helicsBrokerWaitForDisconnect(broker, 200)
destroyBroker(broker)
def test_iteration_async_test():
broker = createBroker(1)
vFed1, fedinfo1 = createValueFederate(1, "fed0")
vFed2, fedinfo2 = createValueFederate(1, "fed1")
# register the publications
pub1 = h.helicsFederateRegisterGlobalPublication(vFed1, "pub1",
h.HELICS_DATA_TYPE_INT)
sub1 = h.helicsFederateRegisterSubscription(vFed2, "pub1")
pub2 = h.helicsFederateRegisterGlobalPublication(vFed2, "pub2",
h.HELICS_DATA_TYPE_INT)
sub2 = h.helicsFederateRegisterSubscription(vFed1, "pub2")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
h.helicsFederateSetTimeProperty(vFed2, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
# vFed1->setLoggingLevel(5)
# vFed2->setLoggingLevel(5)
h.helicsFederateEnterInitializingModeAsync(vFed1)
h.helicsFederateEnterInitializingMode(vFed2)
h.helicsFederateEnterInitializingModeComplete(vFed1)
c1 = 0
c2 = 0
h.helicsPublicationPublishInteger(pub1, c1)
h.helicsPublicationPublishInteger(pub2, c2)
h.helicsFederateEnterExecutingModeAsync(vFed1)
h.helicsFederateEnterExecutingMode(vFed2)
h.helicsFederateEnterExecutingModeComplete(vFed1)
while c1 <= 10:
h.helicsInputGetInteger(sub1), c1
h.helicsInputGetInteger(sub2), c2
c1 += 1
c2 += 1
if c1 <= 10:
h.helicsPublicationPublishInteger(pub1, c1)
h.helicsPublicationPublishInteger(pub2, c2)
h.helicsFederateRequestTimeIterativeAsync(
vFed1, 1.0, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
grantedTime, state = h.helicsFederateRequestTimeIterative(
vFed2, 1.0, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
if c1 <= 10:
# assert state == h.HELICS_ITERATION_RESULT_ITERATING
assert grantedTime == 0.0
else:
# assert state == h.HELICS_ITERATION_RESULT_NEXT_STEP
assert grantedTime == 1.0
grantedTime, state = h.helicsFederateRequestTimeIterativeComplete(
vFed1)
if c1 <= 10:
# assert state == h.HELICS_ITERATION_RESULT_ITERATING
assert grantedTime == 0.0
# assert state == h.HELICS_ITERATION_RESULT_NEXT_STEP
# assert grantedTime == 1.0
destroyFederate(vFed1, fedinfo1)
destroyFederate(vFed2, fedinfo2)
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_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_valuefederate_default_value_tests():
broker = createBroker()
vFed1, fedinfo = createValueFederate(1, "fed0")
inp_raw1 = h.helicsFederateRegisterInput(vFed1, "key1", h.HELICS_DATA_TYPE_RAW, "raw")
inp_raw2 = h.helicsFederateRegisterInput(vFed1, "key2", h.HELICS_DATA_TYPE_RAW, "raw")
inp_bool = h.helicsFederateRegisterInput(vFed1, "key3", h.HELICS_DATA_TYPE_BOOLEAN, "")
inp_time = h.helicsFederateRegisterInput(vFed1, "key4", h.HELICS_DATA_TYPE_TIME, "")
inp_char = h.helicsFederateRegisterInput(vFed1, "key5", h.HELICS_DATA_TYPE_STRING, "")
inp_vect = h.helicsFederateRegisterInput(vFed1, "key6", h.HELICS_DATA_TYPE_VECTOR, "V")
inp_double = h.helicsFederateRegisterInput(vFed1, "key7", h.HELICS_DATA_TYPE_DOUBLE, "kW")
inp_double2 = h.helicsFederateRegisterInput(vFed1, "key8", h.HELICS_DATA_TYPE_DOUBLE, "")
inp_np = h.helicsFederateRegisterInput(vFed1, "key9", h.HELICS_DATA_TYPE_NAMED_POINT, "")
h.helicsInputSetMinimumChange(inp_double, 1100.0)
h.helicsInputSetDefaultDouble(inp_double, 10000.0)
h.helicsInputSetOption(inp_double2, h.HELICS_HANDLE_OPTION_CONNECTION_REQUIRED, True)
pub = h.helicsFederateRegisterPublication(vFed1, "", h.HELICS_DATA_TYPE_INT, "MW")
h.helicsPublicationSetOption(pub, h.HELICS_HANDLE_OPTION_CONNECTION_REQUIRED, True)
h.helicsPublicationAddTarget(pub, "Testfed0/key7")
h.helicsPublicationAddTarget(pub, "Testfed0/key8")
h.helicsInputSetDefaultRaw(inp_raw1, "")
data = "this is a string"
h.helicsInputSetDefaultRaw(inp_raw2, data)
h.helicsInputSetDefaultBoolean(inp_bool, True)
h.helicsInputSetDefaultTime(inp_time, 12.3)
h.helicsInputSetDefaultChar(inp_char, "q")
h.helicsInputSetDefaultVector(inp_vect, [])
h.helicsInputSetDefaultNamedPoint(inp_np, data, 15.7)
h.helicsFederateEnterExecutingMode(vFed1)
assert h.helicsInputGetInjectionUnits(inp_double) == "MW"
assert h.helicsInputGetInjectionUnits(inp_double2) == "MW"
assert h.helicsInputGetType(inp_double) == "double"
assert h.helicsInputGetPublicationType(inp_double) == "int64"
c2 = h.helicsInputGetChar(inp_char)
assert c2 == "q"
h.helicsInputGetVector(inp_vect)
optset = h.helicsInputGetOption(inp_double2, h.HELICS_HANDLE_OPTION_CONNECTION_REQUIRED)
assert optset == 1
optset = h.helicsPublicationGetOption(pub, h.HELICS_HANDLE_OPTION_CONNECTION_REQUIRED)
assert optset == 1
h.helicsPublicationPublishInteger(pub, 12)
h.helicsFederateRequestNextStep(vFed1)
assert h.helicsInputGetDouble(inp_double) == 12000.0
assert h.helicsInputGetDouble(inp_double2) == 12.0
h.helicsPublicationPublishInteger(pub, 13)
h.helicsFederateRequestNextStep(vFed1)
assert h.helicsInputIsUpdated(inp_double) is False
assert h.helicsInputIsUpdated(inp_double2) is True
assert h.helicsInputGetDouble(inp_double) == 12000.0
assert h.helicsInputGetDouble(inp_double2) == 13.0
h.helicsPublicationPublishInteger(pub, 15)
h.helicsFederateRequestNextStep(vFed1)
assert h.helicsInputIsUpdated(inp_double) is True
assert h.helicsInputIsUpdated(inp_double2) is True
h.helicsInputClearUpdate(inp_double)
h.helicsInputClearUpdate(inp_double2)
assert h.helicsInputIsUpdated(inp_double) is False
assert h.helicsInputIsUpdated(inp_double2) is False
_, rval = h.helicsInputGetNamedPoint(inp_np)
assert rval == 15.7
out, rval = h.helicsInputGetNamedPoint(inp_np)
assert out == "this is a string"
assert rval == 15.7
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
def test_valuefederate_creation():
broker = createBroker()
vFed, fedinfo = createValueFederate()
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_valuefederate_subscription_and_publication_registration():
broker = createBroker()
vFed, fedinfo = createValueFederate(1, "fed0")
pubid = h.helicsFederateRegisterPublication(vFed, "pub1", h.HELICS_DATA_TYPE_STRING, "")
pubid2 = h.helicsFederateRegisterGlobalPublication(vFed, "pub2", h.HELICS_DATA_TYPE_INT, "volts")
pubid3 = h.helicsFederateRegisterTypePublication(vFed, "pub3", "double", "V")
subid1 = h.helicsFederateRegisterSubscription(vFed, "sub1", "")
subid2 = h.helicsFederateRegisterSubscription(vFed, "sub2", "")
subid3 = h.helicsFederateRegisterSubscription(vFed, "sub3", "V")
h.helicsFederateEnterExecutingMode(vFed)
publication_type = h.helicsPublicationGetType(pubid3)
assert publication_type == "double"
sub_key = h.helicsSubscriptionGetKey(subid1)
assert sub_key == "sub1"
sub_type = h.helicsInputGetType(subid1)
assert sub_type == ""
sub_key = h.helicsSubscriptionGetKey(subid2)
assert sub_key == "sub2"
sub_key = h.helicsSubscriptionGetKey(subid3)
assert sub_key == "sub3"
sub_type = h.helicsInputGetType(subid3)
assert sub_type == ""
sub_units = h.helicsInputGetUnits(subid3)
assert sub_units == "V"
sub_type = h.helicsInputGetType(subid2)
assert sub_type == ""
subid_b = h.helicsFederateGetSubscription(vFed, "sub1")
tmp = h.helicsSubscriptionGetKey(subid_b)
assert tmp == "sub1"
# check the getSubscriptionByIndex function
subid_c = h.helicsFederateGetInputByIndex(vFed, 2)
tmp = h.helicsInputGetUnits(subid_c)
assert tmp == "V"
# check publications
sv = h.helicsPublicationGetKey(pubid)
sv2 = h.helicsPublicationGetKey(pubid2)
assert sv == "Testfed0/pub1"
assert sv2 == "pub2"
pub3name = h.helicsPublicationGetKey(pubid3)
assert pub3name == "Testfed0/pub3"
type = h.helicsPublicationGetType(pubid3)
assert type == "double"
units = h.helicsPublicationGetUnits(pubid3)
assert units == "V"
# check the getSubscription function
pubid_b = h.helicsFederateGetPublication(vFed, "Testfed0/pub1")
tmp = h.helicsPublicationGetType(pubid_b)
assert tmp == "string"
# check the getSubscriptionByIndex function
pubid_c = h.helicsFederateGetPublicationByIndex(vFed, 1)
tmp = h.helicsPublicationGetUnits(pubid_c)
assert tmp == "volts"
# this one should be invalid
# @test_throws h.HELICSErrorInvalidArgument pubid_d = h.helicsFederateGetPublicationByIndex(vFed, 5)
h.helicsFederateFinalize(vFed)
state = h.helicsFederateGetState(vFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def test_filter_test_types_function_two_stage():
broker = createBroker(3)
fFed, fedinfo1 = createMessageFederate(1, "filter")
fFed2, fedinfo2 = createMessageFederate(1, "filter2")
mFed, fedinfo3 = 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", 1.25)
f2 = h.helicsFederateRegisterFilter(fFed2, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port1")
h.helicsFilterSet(f2, "delay", 1.25)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingModeAsync(fFed2)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
h.helicsFederateEnterExecutingModeComplete(fFed2)
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, 0.0)
h.helicsFederateRequestTimeAsync(fFed, 1.0)
h.helicsFederateRequestTime(fFed2, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
h.helicsFederateRequestTimeComplete(fFed)
assert h.helicsFederateHasMessage(mFed) is False
h.helicsFederateRequestTimeAsync(mFed, 0.0)
h.helicsFederateRequestTimeAsync(fFed2, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
h.helicsFederateRequestTimeComplete(fFed2)
assert h.helicsEndpointHasMessage(p2) is False
h.helicsFederateRequestTimeAsync(fFed, 3.0)
h.helicsFederateRequestTimeAsync(fFed2, 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.helicsFederateRequestTimeComplete(fFed)
h.helicsFederateRequestTimeComplete(fFed2)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalizeAsync(fFed)
h.helicsFederateFinalize(fFed2)
h.helicsFederateFinalizeComplete(mFed)
h.helicsFederateFinalizeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(fFed2, fedinfo2)
destroyFederate(mFed, fedinfo3)
destroyBroker(broker)
def test_bad_input_type_publication_2_tests():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "test")
pubid = h.helicsFederateRegisterGlobalTypePublication(
vFed1, "pub1", "string", "")
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorRegistrationFailure
pubid2 = h.helicsFederateRegisterGlobalTypePublication(
vFed1, "pub1", "string", "")
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidArgument
h.helicsFederateRegisterFromPublicationJSON(vFed1, "unknownfile.json")
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorExternalArgument
h.helicsFederateRegisterInterfaces(vFed1, "unknownfile.json")
subid = h.helicsFederateRegisterTypeInput(vFed1, "inp1", "string", "")
# @test_throws h.HELICSErrorRegistrationFailure
with pt.raises(h.HelicsException):
subid2 = h.helicsFederateRegisterTypeInput(vFed1, "inp1", "string", "")
h.helicsInputAddTarget(subid, "pub1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
h.helicsFederateEnterExecutingModeIterativeAsync(
vFed1, h.HELICS_ITERATION_REQUEST_NO_ITERATION)
res = h.helicsFederateEnterExecutingModeIterativeComplete(vFed1)
assert res == h.HELICS_ITERATION_RESULT_NEXT_STEP
h.helicsPublicationPublishTime(pubid, 27.0)
# @test_throws h.HELICSErrorInvalidArgument
with pt.raises(h.HelicsException):
h.helicsFederatePublishJSON(vFed1, "unknownfile.json")
h.helicsFederateRequestNextStep(vFed1)
string = h.helicsInputGetString(subid)
assert string[0] == "2"
assert string[1] == "7"
h.helicsFederateClearUpdates(vFed1)
h.helicsFederateFinalize(vFed1)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishRaw(pubid, string.encode())
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishString(pubid, string)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishInteger(pubid, 5)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishBoolean(pubid, True)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishDouble(pubid, 39.2)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishTime(pubid, 19.2)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishChar(pubid, "a")
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishComplex(pubid, 2.5 + -9.8j)
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishVector(pubid, [1.3, 2.9])
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsPublicationPublishNamedPoint(pubid, "hello world", 2.0)
destroyFederate(vFed1, fedinfo)
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_bad_inputs_input_tests():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
pubid = h.helicsFederateRegisterGlobalPublication(
vFed1, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "")
subid = h.helicsFederateRegisterInput(vFed1, "inp1",
h.HELICS_DATA_TYPE_DOUBLE, "")
# @test_throws h.HELICSErrorRegistrationFailure
with pt.raises(h.HelicsException):
subid2 = h.helicsFederateRegisterInput(vFed1, "inp1",
h.HELICS_DATA_TYPE_DOUBLE, "")
h.helicsInputAddTarget(subid, "pub1")
vf2 = h.helicsFederateClone(vFed1)
assert h.helicsFederateGetName(vFed1) == h.helicsFederateGetName(vf2)
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
# @test_throws h.HELICSErrorInvalidObject
with pt.raises(h.HelicsException):
ept = h.helicsFederateRegisterEndpoint(vFed1, "ept1", "")
h.helicsFederateEnterInitializingMode(vFed1)
h.helicsPublicationPublishDouble(pubid, 27.0)
comp = h.helicsFederateEnterExecutingModeIterative(
vFed1, h.HELICS_ITERATION_REQUEST_FORCE_ITERATION)
assert comp == h.HELICS_ITERATION_RESULT_ITERATING
val = h.helicsInputGetDouble(subid)
assert val == 27.0
valt = h.helicsInputGetTime(subid)
assert valt == 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
# expect error entering initializing Mode again
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsFederateEnterInitializingMode(vFed1)
# expect error entering initializing Mode again
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsFederateEnterInitializingModeAsync(vFed1)
# expect error entering initializing Mode again
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsFederateEnterInitializingModeComplete(vFed1)
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
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_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)
