def test22(self):
_log.analyze("TESTRUN", "+", {})
src = utils.new_actor(self.rt1, 'std.Counter', 'src')
ity = utils.new_actor(self.rt2, 'std.Identity', 'ity')
snk = utils.new_actor_wargs(self.rt3, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt2, ity, 'token', self.rt1.id, src, 'integer')
utils.connect(self.rt3, snk, 'token', self.rt2.id, ity, 'token')
interval = 0.5
for retries in range(1, 5):
time.sleep(retries * interval)
actual = utils.report(self.rt3, snk)
if len(actual) > 10:
break
self.assert_lists_equal(range(1, 11), actual)
time.sleep(0.1)
actual = utils.report(self.rt3, snk)
self.assert_lists_equal(range(1, 10), actual)
utils.delete_actor(self.rt1, src)
utils.delete_actor(self.rt2, ity)
utils.delete_actor(self.rt3, snk)
def test31(self):
# Verify that fanout defined implicitly in scripts is handled correctly
_log.analyze("TESTRUN", "+", {})
script = """
src : std.Counter()
snk1 : io.StandardOut(store_tokens=1, quiet=1)
snk2 : io.StandardOut(store_tokens=1, quiet=1)
src.integer > snk1.token
src.integer > snk2.token
"""
app_info, errors, warnings = compiler.compile(script, "test31")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.1)
snk1 = d.actor_map['test31:snk1']
snk2 = d.actor_map['test31:snk2']
actual1 = utils.report(self.rt1, snk1)
actual2 = utils.report(self.rt1, snk2)
expected = list(range(1, 10))
self.assert_lists_equal(expected, actual1)
self.assert_lists_equal(expected, actual2)
d.destroy()
def testTwoStepMigrateSourceSink(self):
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(1)
utils.migrate(self.rt1, src, self.rt2.id)
utils.report(self.rt1, snk)
time.sleep(1)
utils.migrate(self.rt1, snk, self.rt2.id)
time.sleep(1)
actual = utils.report(self.rt2, snk)
self.assert_lists_equal(range(1,20), actual, min_length=15)
def testBadSelect(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.Counter()
const : std.Constant(data=2, n=-1)
route : std.Select()
snk : io.StandardOut(store_tokens=1, quiet=1)
term : std.Terminator()
src.integer > route.data
const.token > route.select
route.case_true > term.void
route.case_false > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testBadSelect")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testBadSelect:snk']
actual = utils.report(self.rt1, snk)
expected = list(range(1, 10))
self.assert_lists_equal(expected, actual)
d.destroy()
def testGreaterThanOrEqual(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.Counter()
const : std.Constant(data=5, n=-1)
pred : std.Compare(op=">=")
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > pred.a
const.token > pred.b
pred.result > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testGreaterThanOrEqual")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.1)
snk = d.actor_map['testGreaterThanOrEqual:snk']
actual = utils.report(self.rt1, snk)
expected = [x >= 5 for x in range(1, 10)]
self.assert_lists_equal(expected, actual)
d.destroy()
def testDeselectBadSelect(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.Counter()
const_5 : std.Constantify(constant=5)
const_0 : std.Constant(data=0, n=11)
ds : std.Deselect()
snk : io.StandardOut(store_tokens=1, quiet=1)
const_0.token > ds.case_false
src.integer > ds.case_true
const_0.token > const_5.in
const_5.out > ds.select
ds.data > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testDeselectBadSelect")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testDeselectBadSelect:snk']
actual = utils.report(self.rt1, snk)
expected = [0] * 10
self.assert_lists_equal(expected, actual, min_length=10)
d.destroy()
def testSimpleState(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.CountTimer()
sum : std.Sum()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > sum.integer
sum.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
csum = d.actor_map['simple:sum']
snk = d.actor_map['simple:snk']
utils.migrate(self.rt1, csum, self.rt2.id)
time.sleep(1)
actual = utils.report(self.rt1, snk)
expected = [sum(range(i+1)) for i in range(1,10)]
self.assert_lists_equal(expected, actual)
d.destroy()
def testVoidActor(self):
# Verify that the null port of a std.Void actor behaves as expected
_log.analyze("TESTRUN", "+", {})
script = """
src1 : std.Counter()
src2 : std.Void()
join : std.Join()
snk : io.StandardOut(store_tokens=1, quiet=1)
src1.integer > join.token_1
src2.void > join.token_2
join.token > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testVoidActor")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.4)
snk = d.actor_map['testVoidActor:snk']
actual = utils.report(self.rt1, snk)
expected = list(range(1, 10))
self.assert_lists_equal(expected, actual)
d.destroy()
def testComponentConstantArgumentAsImplicitActor(self):
_log.analyze("TESTRUN", "+", {})
script = """
define FOO = "hup"
component Count(data) -> seq {
i : std.Identity()
data > i.token
i.token > .seq
}
src : Count(data=FOO)
snk : io.StandardOut(store_tokens=1, quiet=1)
src.seq > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testComponentConstantArgumentAsImplicitActor")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testComponentConstantArgumentAsImplicitActor:snk']
actual = utils.report(self.rt1, snk)
expected = ["hup"]*10
self.assert_lists_equal(expected, actual, min_length=10)
d.destroy()
def testDeselectFalse(self):
script = """
src : std.Counter()
const_5 : std.Constantify(constant=5)
const_0 : std.Constant(data=0, n=-1)
const_1 : std.Constant(data=1, n=-1)
comp : std.Compare(op="<=")
ds : std.Deselect()
snk : io.StandardOut(store_tokens=1, quiet=1)
const_0.token > ds.case_true
const_1.token > ds.case_false
src.integer > comp.a
src.integer > const_5.in
const_5.out > comp.b
comp.result > ds.select
ds.data > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testDeselectFalse")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testDeselectFalse:snk']
actual = utils.report(self.rt1, snk)
expected = [0] * 5 + [1] * 5
self.assert_lists_equal(expected, actual, min_length=10)
def testSepDeployShadow(self):
_log.analyze("TESTRUN", "+", {})
global rt1
global rt2
global test_script_dir
self.verify_storage()
from calvin.Tools.cscontrol import control_deploy as deploy_app
from collections import namedtuple
DeployArgs = namedtuple('DeployArgs', ['node', 'attr', 'script','reqs', 'check'])
args = DeployArgs(node='http://%s:5003' % ip_addr,
script=open(test_script_dir+"test_shadow1.calvin"), attr=None,
reqs=test_script_dir+"test_shadow1.deployjson", check=False)
result = {}
try:
result = deploy_app(args)
except:
raise Exception("Failed deployment of app %s, no use to verify if requirements fulfilled" % args.script.name)
#print "RESULT:", result
time.sleep(2)
actors = [utils.get_actors(rt1), utils.get_actors(rt2)]
# src -> rt1, sum -> rt2, snk -> rt1
assert result['actor_map']['test_shadow1:src'] in actors[0]
assert result['actor_map']['test_shadow1:sum'] in actors[1]
assert result['actor_map']['test_shadow1:snk'] in actors[0]
actual = utils.report(rt1, result['actor_map']['test_shadow1:snk'])
assert len(actual) > 5
utils.delete_application(rt1, result['application_id'])
def testStringConstantOnCompPort(self):
_log.analyze("TESTRUN", "+", {})
script = """
define MEANING = "42"
component Foo() -> out {
i:std.Identity()
MEANING > i.token
i.token > .out
}
src : Foo()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.out > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testStringConstantOnCompPort")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testStringConstantOnCompPort:snk']
actual = utils.report(self.rt1, snk)
expected = ["42"]*10
self.assert_lists_equal(expected, actual, min_length=10)
d.destroy()
def testAppDestructionAllRemote(self):
script = """
src : std.CountTimer()
sum : std.Sum()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > sum.integer
sum.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
src = d.actor_map['simple:src']
csum = d.actor_map['simple:sum']
snk = d.actor_map['simple:snk']
utils.migrate(self.rt1, src, self.rt2.id)
utils.migrate(self.rt1, csum, self.rt2.id)
utils.migrate(self.rt1, snk, self.rt2.id)
time.sleep(1)
actual = utils.report(self.rt2, snk)
expected = [sum(range(i+1)) for i in range(1,10)]
self.assert_lists_equal(expected, actual)
utils.delete_application(self.rt1, d.app_id)
time.sleep(0.5)
self.assertIsNone(utils.get_actor(self.rt1, src))
self.assertIsNone(utils.get_actor(self.rt1, csum))
self.assertIsNone(utils.get_actor(self.rt1, snk))
self.assertIsNone(utils.get_application(self.rt1, d.app_id))
def testEmptyStringTriggerJoin(self):
_log.analyze("TESTRUN", "+", {})
datafile = absolute_filename('data.txt')
script = """
fname : std.Constant(data="%s")
src : io.FileReader()
join : text.LineJoin()
snk : io.StandardOut(store_tokens=1, quiet=1)
fname.token > src.filename
src.out > join.line
join.text > snk.token
""" % (datafile, )
app_info, errors, warnings = compiler.compile(script, "testCustomTriggerJoin")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testCustomTriggerJoin:snk']
actual = utils.report(self.rt1, snk)
with open(datafile, "r") as fp:
expected = [l.rstrip() for l in fp.readlines()]
expected = ['\n'.join(expected[:10]), '\n'.join(expected[10:])]
self.assert_lists_equal(expected, actual, min_length=2)
d.destroy()
def testRegexCaptureNoMatch(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.Constant(data="x24.1632", n=1)
regex : text.RegexMatch(regex=!"(\d+)\.\d+")
snk : io.StandardOut(store_tokens=1, quiet=1)
term : std.Terminator()
src.token > regex.text
regex.no_match > snk.token
regex.match > term.void
"""
app_info, errors, warnings = compiler.compile(script, "testRegexCaptureNoMatch")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testRegexCaptureNoMatch:snk']
actual = utils.report(self.rt1, snk)
expected = ["x24.1632"]
self.assert_lists_equal(expected, actual, min_length=1)
d.destroy()
def test30(self):
src = utils.new_actor(self.rt1, 'std.Counter', 'src')
snk1 = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk1', store_tokens=1, quiet=1)
snk2 = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk2', store_tokens=1, quiet=1)
utils.set_port_property(self.rt1, src, 'out', 'integer', 'fanout', 2)
utils.connect(self.rt1, snk1, 'token', self.rt1.id, src, 'integer')
utils.connect(self.rt1, snk2, 'token', self.rt1.id, src, 'integer')
time.sleep(0.2)
actual1 = utils.report(self.rt1, snk1)
actual2 = utils.report(self.rt1, snk2)
self.assert_lists_equal(list(range(1, 10)), actual1)
self.assert_lists_equal(list(range(1, 10)), actual2)
def test21(self):
src = utils.new_actor(self.rt1, 'std.Counter', 'src')
ity = utils.new_actor(self.rt2, 'std.Identity', 'ity')
snk = utils.new_actor_wargs(self.rt3, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt3, snk, 'token', self.rt2.id, ity, 'token')
utils.connect(self.rt2, ity, 'token', self.rt1.id, src, 'integer')
time.sleep(0.1)
actual = utils.report(self.rt3, snk)
while len(actual) < 10:
time.sleep(0.1)
actual = utils.report(self.rt3, snk)
self.assert_lists_equal(range(1, 11), actual)
def expected_tokens(rt, actor_id, src_actor_type):
tokens = utils.report(rt, actor_id)
if src_actor_type == 'std.CountTimer':
return expected_counter(tokens)
if src_actor_type == 'std.Sum':
return expected_sum(tokens)
return None
def testAppDestructionAllRemote(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.CountTimer()
sum : std.Sum()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > sum.integer
sum.integer > snk.token
"""
import sys
from twisted.python import log
log.startLogging(sys.stdout)
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.2)
src = d.actor_map['simple:src']
csum = d.actor_map['simple:sum']
snk = d.actor_map['simple:snk']
utils.migrate(self.rt1, src, self.rt2.id)
utils.migrate(self.rt1, csum, self.rt2.id)
utils.migrate(self.rt1, snk, self.rt2.id)
time.sleep(.5)
actual = utils.report(self.rt2, snk)
expected = [sum(range(i+1)) for i in range(1,10)]
self.assert_lists_equal(expected, actual)
utils.delete_application(self.rt1, d.app_id)
for a in range(20):
all_removed = None
try:
self.assertIsNone(utils.get_actor(self.rt1, csum))
self.assertIsNone(utils.get_actor(self.rt1, snk))
self.assertIsNone(utils.get_actor(self.rt2, src))
self.assertIsNone(utils.get_actor(self.rt2, csum))
self.assertIsNone(utils.get_actor(self.rt2, snk))
self.assertIsNone(utils.get_actor(self.rt3, src))
self.assertIsNone(utils.get_actor(self.rt3, csum))
self.assertIsNone(utils.get_actor(self.rt3, snk))
except AssertionError as e:
print a, e
all_removed = e
if all_removed is None:
break
time.sleep(1)
if all_removed:
raise all_removed
self.assertIsNone(utils.get_application(self.rt1, d.app_id))
self.assertIsNone(utils.get_application(self.rt2, d.app_id))
self.assertIsNone(utils.get_application(self.rt3, d.app_id))
def testLocalSourceSink(self):
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(.5)
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 10), actual)
def testFileScript(self):
scriptname = 'test1'
scriptfile = absolute_filename("scripts/%s.calvin" % (scriptname, ))
app_info, errors, warnings = compiler.compile_file(scriptfile)
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
src = d.actor_map['%s:src' % scriptname]
snk = d.actor_map['%s:snk' % scriptname]
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 20), actual)
def test10(self):
# Two actors, doesn't seem to trigger the bug
src = utils.new_actor(self.rt1, 'std.Counter', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(0.1)
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 10), actual)
def testInlineScript(self):
script = """
src : std.CountTimer()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
snk = d.actor_map['simple:snk']
actual = utils.report(self.rt1, (snk))
self.assert_lists_equal(range(1, 20), actual)
def test32(self):
# Verify that fanout from component inports is handled correctly
_log.analyze("TESTRUN", "+", {})
script = """
component Foo() in -> a, b{
a : std.Identity()
b : std.Identity()
.in > a.token
.in > b.token
a.token > .a
b.token > .b
}
snk2 : io.StandardOut(store_tokens=1, quiet=1)
snk1 : io.StandardOut(store_tokens=1, quiet=1)
foo : Foo()
req : std.Counter()
req.integer > foo.in
foo.a > snk1.token
foo.b > snk2.token
"""
app_info, errors, warnings = compiler.compile(script, "test32")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.1)
snk1 = d.actor_map['test32:snk1']
snk2 = d.actor_map['test32:snk2']
actual1 = utils.report(self.rt1, snk1)
actual2 = utils.report(self.rt1, snk2)
expected = list(range(1, 10))
self.assert_lists_equal(expected, actual1)
self.assert_lists_equal(expected, actual2)
d.destroy()
def test10(self):
_log.analyze("TESTRUN", "+", {})
# Two actors, doesn't seem to trigger the bug
src = utils.new_actor(self.rt1, 'std.Counter', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(0.1)
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 10), actual)
utils.delete_actor(self.rt1, src)
utils.delete_actor(self.rt1, snk)
def testMigrateSource(self):
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1,
'io.StandardOut',
'snk',
store_tokens=1,
quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(.4)
utils.migrate(self.rt1, src, self.rt2.id)
time.sleep(.6)
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 10), actual)
def testLiteralOnPort(self):
script = """
snk : io.StandardOut(store_tokens=1, quiet=1)
42 > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testLiteralOnPort")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testLiteralOnPort:snk']
actual = utils.report(self.rt1, snk)
expected = [42]*10
self.assert_lists_equal(expected, actual, min_length=10)
def testMigrateSink(self):
_log.analyze("TESTRUN", "+", {})
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(.4)
utils.migrate(self.rt1, snk, self.rt2.id)
time.sleep(.6)
actual = utils.report(self.rt2, snk)
self.assert_lists_equal(range(1, 10), actual)
utils.delete_actor(self.rt1, src)
utils.delete_actor(self.rt2, snk)
def test25(self):
src = utils.new_actor(self.rt1, 'std.Counter', 'src')
ity = utils.new_actor(self.rt1, 'std.Identity', 'ity')
snk = utils.new_actor_wargs(self.rt1,
'io.StandardOut',
'snk',
store_tokens=1,
quiet=1)
utils.connect(self.rt1, ity, 'token', self.rt1.id, src, 'integer')
utils.connect(self.rt1, snk, 'token', self.rt1.id, ity, 'token')
time.sleep(0.5)
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 10), actual)
def testInlineScript(self):
_log.analyze("TESTRUN", "+", {})
script = """
src : std.CountTimer()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
snk = d.actor_map['simple:snk']
actual = utils.report(self.rt1, (snk))
self.assert_lists_equal(range(1, 20), actual)
d.destroy()
def testLiteralOnPort(self):
script = """
snk : io.StandardOut(store_tokens=1, quiet=1)
42 > snk.token
"""
app_info, errors, warnings = compiler.compile(script,
"testLiteralOnPort")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testLiteralOnPort:snk']
actual = utils.report(self.rt1, snk)
expected = [42] * 10
self.assert_lists_equal(expected, actual, min_length=10)
def test20(self):
_log.analyze("TESTRUN", "+", {})
src = utils.new_actor(self.rt1, 'std.Counter', 'src')
ity = utils.new_actor(self.rt1, 'std.Identity', 'ity')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, ity, 'token')
utils.connect(self.rt1, ity, 'token', self.rt1.id, src, 'integer')
time.sleep(0.2)
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 11), actual)
utils.delete_actor(self.rt1, src)
utils.delete_actor(self.rt1, ity)
utils.delete_actor(self.rt1, snk)
def test11(self):
# Same as test10, but scripted
script = """
src : std.Counter()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['simple:snk']
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 10), actual)
def testConstant(self):
script = """
define FOO = 42
src : std.Constant(data=FOO, n=10)
snk : io.StandardOut(store_tokens=1, quiet=1)
src.token > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testConstant")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testConstant:snk']
actual = utils.report(self.rt1, snk)
expected = [42] * 10
self.assert_lists_equal(expected, actual, min_length=10)
def testConstantRecursiveOnPort(self):
script = """
define FOO = BAR
define BAR = "yay"
snk : io.StandardOut(store_tokens=1, quiet=1)
FOO > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testConstantRecursiveOnPort")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testConstantRecursiveOnPort:snk']
actual = utils.report(self.rt1, snk)
expected = ["yay"]*10
self.assert_lists_equal(expected, actual, min_length=10)
def test25(self):
_log.analyze("TESTRUN", "+", {})
src = utils.new_actor(self.rt1, 'std.Counter', 'src')
ity = utils.new_actor(self.rt1, 'std.Identity', 'ity')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, ity, 'token', self.rt1.id, src, 'integer')
utils.connect(self.rt1, snk, 'token', self.rt1.id, ity, 'token')
time.sleep(0.2)
actual = utils.report(self.rt1, snk)
self.assert_lists_equal(range(1, 10), actual)
utils.delete_actor(self.rt1, src)
utils.delete_actor(self.rt1, ity)
utils.delete_actor(self.rt1, snk)
def testConstant(self):
script = """
define FOO = 42
src : std.Constant(data=FOO, n=10)
snk : io.StandardOut(store_tokens=1, quiet=1)
src.token > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testConstant")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testConstant:snk']
actual = utils.report(self.rt1, snk)
expected = [42]*10
self.assert_lists_equal(expected, actual, min_length=10)
def testConstantRecursiveOnPort(self):
script = """
define FOO = BAR
define BAR = "yay"
snk : io.StandardOut(store_tokens=1, quiet=1)
FOO > snk.token
"""
app_info, errors, warnings = compiler.compile(
script, "testConstantRecursiveOnPort")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testConstantRecursiveOnPort:snk']
actual = utils.report(self.rt1, snk)
expected = ["yay"] * 10
self.assert_lists_equal(expected, actual, min_length=10)
def test26(self):
# Same as test20
script = """
src : std.Counter()
ity : std.Identity()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > ity.token
ity.token > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.4)
snk = d.actor_map['simple:snk']
actual = utils.report(self.rt1, snk)
expected = list(range(1, 10))
self.assert_lists_equal(expected, actual)
def testConstantOnPort(self):
_log.analyze("TESTRUN", "+", {})
script = """
define FOO = "Hello"
snk : io.StandardOut(store_tokens=1, quiet=1)
FOO > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testConstantOnPort")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testConstantOnPort:snk']
actual = utils.report(self.rt1, snk)
expected = ["Hello"]*10
self.assert_lists_equal(expected, actual, min_length=10)
d.destroy()
def testEqual(self):
script = """
src : std.Counter()
const : std.Constant(data=5, n=-1)
pred : std.Compare(op="=")
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > pred.a
const.token > pred.b
pred.result > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testEqual")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testEqual:snk']
actual = utils.report(self.rt1, snk)
expected = [x == 5 for x in range(1, 10)]
self.assert_lists_equal(expected, actual)
def testRegexMatch(self):
script = """
src : std.Constant(data="24.1632", n=1)
regex : text.RegexMatch(regex=!"\d+\.\d+")
snk : io.StandardOut(store_tokens=1, quiet=1)
term : std.Terminator()
src.token > regex.text
regex.match > snk.token
regex.no_match > term.null
"""
app_info, errors, warnings = compiler.compile(script, "testRegexMatch")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testRegexMatch:snk']
actual = utils.report(self.rt1, snk)
expected = ["24.1632"]
self.assert_lists_equal(expected, actual, min_length=1)
def testComponentArgument(self):
script = """
component Count(len) -> seq {
src : std.Constant(data="hup", n=len)
src.token > .seq
}
src : Count(len=5)
snk : io.StandardOut(store_tokens=1, quiet=1)
src.seq > snk.token
"""
app_info, errors, warnings = compiler.compile(script,
"testComponentArgument")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testComponentArgument:snk']
actual = utils.report(self.rt1, snk)
expected = ["hup"] * 5
self.assert_lists_equal(expected, actual, min_length=5)
def testTerminatorActor(self):
# Verify that the null port of a std.Terminator actor behaves as expected
script = """
src : std.Counter()
term : std.Terminator()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > term.null
src.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script,
"testTerminatorActor")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testTerminatorActor:snk']
actual = utils.report(self.rt1, snk)
expected = list(range(1, 10))
self.assert_lists_equal(expected, actual)
def testSimpleState(self):
script = """
src : std.CountTimer()
sum : std.Sum()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.integer > sum.integer
sum.integer > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "simple")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(1)
csum = d.actor_map['simple:sum']
snk = d.actor_map['simple:snk']
utils.migrate(self.rt1, csum, self.rt2.id)
time.sleep(1)
actual = utils.report(self.rt1, snk)
expected = [sum(range(i + 1)) for i in range(1, 10)]
self.assert_lists_equal(expected, actual)
def testMigrateSource(self):
_log.analyze("TESTRUN", "+", {})
src = utils.new_actor(self.rt1, 'std.CountTimer', 'src')
snk = utils.new_actor_wargs(self.rt1, 'io.StandardOut', 'snk', store_tokens=1, quiet=1)
utils.connect(self.rt1, snk, 'token', self.rt1.id, src, 'integer')
time.sleep(1)
utils.migrate(self.rt1, src, self.rt2.id)
interval = 0.5
for retries in range(1,5):
time.sleep(interval * retries)
actual = utils.report(self.rt1, snk)
if len(actual) > 10 :
break
self.assert_lists_equal(range(1, 10), actual)
utils.delete_actor(self.rt2, src)
utils.delete_actor(self.rt1, snk)
def testLiteralOnCompPort(self):
script = """
component Foo() -> out {
i:std.Stringify()
42 > i.in
i.out > .out
}
src : Foo()
snk : io.StandardOut(store_tokens=1, quiet=1)
src.out > snk.token
"""
app_info, errors, warnings = compiler.compile(script,
"testLiteralOnCompPort")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testLiteralOnCompPort:snk']
actual = utils.report(self.rt1, snk)
expected = ["42"] * 10
self.assert_lists_equal(expected, actual, min_length=10)
def testComponentArgumentAsImplicitActor(self):
script = """
component Count(data) -> seq {
i : std.Identity()
data > i.token
i.token > .seq
}
src : Count(data="hup")
snk : io.StandardOut(store_tokens=1, quiet=1)
src.seq > snk.token
"""
app_info, errors, warnings = compiler.compile(
script, "testComponentArgumentAsImplicitActor")
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(.1)
snk = d.actor_map['testComponentArgumentAsImplicitActor:snk']
actual = utils.report(self.rt1, snk)
expected = ["hup"] * 10
self.assert_lists_equal(expected, actual, min_length=10)
def testVoidActor(self):
# Verify that the null port of a std.Void actor behaves as expected
script = """
src1 : std.Counter()
src2 : std.Void()
join : std.Join()
snk : io.StandardOut(store_tokens=1, quiet=1)
src1.integer > join.token_1
src2.void > join.token_2
join.token > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testVoidActor")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.4)
snk = d.actor_map['testVoidActor:snk']
actual = utils.report(self.rt1, snk)
expected = list(range(1, 10))
self.assert_lists_equal(expected, actual)
def testBasicJoin(self):
datafile = absolute_filename('data.txt')
script = """
fname : std.Constant(data="%s")
src : io.FileReader()
join : text.LineJoin()
snk : io.StandardOut(store_tokens=1, quiet=1)
fname.token > src.filename
src.out > join.line
join.text > snk.token
""" % (datafile, )
app_info, errors, warnings = compiler.compile(script, "testBasicJoin")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testBasicJoin:snk']
actual = utils.report(self.rt1, snk)
with open(datafile, "r") as fp:
expected = ["\n".join([l.rstrip() for l in fp.readlines()])]
self.assert_lists_equal(expected, actual, min_length=1)
def testBadSelect(self):
script = """
src : std.Counter()
const : std.Constant(data=2, n=-1)
route : std.Select()
snk : io.StandardOut(store_tokens=1, quiet=1)
term : std.Terminator()
src.integer > route.data
const.token > route.select
route.true > term.null
route.false > snk.token
"""
app_info, errors, warnings = compiler.compile(script, "testBadSelect")
print errors
d = deployer.Deployer(self.rt1, app_info)
d.deploy()
time.sleep(0.5)
snk = d.actor_map['testBadSelect:snk']
actual = utils.report(self.rt1, snk)
expected = list(range(1, 10))
self.assert_lists_equal(expected, actual)
def testSepDeployShadow(self):
_log.analyze("TESTRUN", "+", {})
global rt1
global rt2
global test_script_dir
self.verify_storage()
from calvin.Tools.cscontrol import control_deploy as deploy_app
from collections import namedtuple
DeployArgs = namedtuple('DeployArgs',
['node', 'attr', 'script', 'reqs', 'check'])
args = DeployArgs(node='http://%s:5003' % ip_addr,
script=open(test_script_dir + "test_shadow1.calvin"),
attr=None,
reqs=test_script_dir + "test_shadow1.deployjson",
check=False)
result = {}
try:
result = deploy_app(args)
except:
raise Exception(
"Failed deployment of app %s, no use to verify if requirements fulfilled"
% args.script.name)
#print "RESULT:", result
time.sleep(2)
actors = [utils.get_actors(rt1), utils.get_actors(rt2)]
# src -> rt1, sum -> rt2, snk -> rt1
assert result['actor_map']['test_shadow1:src'] in actors[0]
assert result['actor_map']['test_shadow1:sum'] in actors[1]
assert result['actor_map']['test_shadow1:snk'] in actors[0]
actual = utils.report(rt1, result['actor_map']['test_shadow1:snk'])
assert len(actual) > 5
utils.delete_application(rt1, result['application_id'])
def actual_tokens(rt, actor_id):
return utils.report(rt, actor_id)
