def run_test():
modifier,data_reader = Waldo.same_host_create(Modifier).same_host_create(DataReader)
# check peered value is initialized properly
if modifier.read_peered_num() != 22:
print '\nErr: incorrect modifier initial val of peered num'
return False
if data_reader.read_peered_num() != 22:
print '\nErr: incorrect data reader initial val of peered num'
return False
# check modifier can increment
if modifier.increment_peered_num() != 23:
print '\nErr: incorrect modifier return from peered num increment'
return False
# check modifier sees increment
if modifier.read_peered_num() != 23:
print '\nErr: incorrect modifier return from peered num read'
return False
# check data reader sees increment
if data_reader.read_peered_num() != 23:
print '\nErr: incorrect data reader return from peered num read'
return False
# check modifier can increment
if modifier.increment_peered_num() != 24:
print '\nErr: incorrect second modifier return from peered num increment'
return False
if modifier.increment_peered_num() != 25:
print '\nErr: incorrect second modifier return from peered num increment'
return False
# check work on peered map
to_add_list = [
('r',{ 'a': True, 'b': False}),
('dl',{ 'a': False, 'b': False}),
('m',{ 'a': False, 'b': True}),
('dl',{ 'a': True, 'b': False})]
first_time = True
for index,inner_map_to_add in to_add_list:
modifier.add_inner_map(index,inner_map_to_add)
if data_reader.read_inner_map(index) != inner_map_to_add:
print '\nErr: problem with updating peered nested map'
return False
return True
def run_test():
sideA, sideB = (
Waldo.same_host_create(SideA).same_host_create(SideB))
sideX, sideY=(
Waldo.same_host_create(SideA).same_host_create(SideB))
in_val = 320
if sideA.get_struct_from_other_side(sideX,in_val) != in_val:
print '\nErr: getting struct from endpoint call'
return False
if sideA.get_partner_struct(in_val) != in_val:
print '\nErr: getting struct from partner'
return False
# test changes to input struct across sequences
inc1 = 39
inc2 = 5
if sideA.input_struct_sequence(inc1,inc2) != (inc1 + inc2):
print '\nErr: input struct sequence did not increment correctly'
return False
# test that can insert a struct into a map and access its fields
# from within map
expected_num = 390
if sideA.test_struct_map('hello',expected_num) != expected_num:
print '\nErr: structs in maps is broken'
return False
# test that can serialize maps of structs
sideA.test_sequence_struct_map()
return True
def run_test():
sideA, sideB = (
Waldo.same_host_create(
SideA,print_debug).same_host_create(SideB,print_debug))
texta, textb = ('a','b')
received_texta, received_textb = sideA.test_two_sequences(texta,textb)
if (received_texta != texta) or (received_textb != textb):
err_msg = '\nError: did not get correct values back when '
err_msg += 'initiating a 2-sequence test'
print err_msg
return False
return True
def run_test():
a_num = 3902
a_index = 133
b_num = 302
b_index = 33
side_a, side_b = (
Waldo.same_host_create(SideA,a_num,a_index).same_host_create(SideB,b_num))
list_of_endpoints, map_of_endpoints = side_a.get_self_holders()
# load sideb into external list and map
side_b.append_self_to_list(list_of_endpoints)
side_b.append_self_to_map(b_index,map_of_endpoints)
# make endpoint calls on all endpoints in the list (ie, sideA and
# sideB) and test that their values are what should be expected
# for sidea's and sideb's internal numbers
endpoint_num_list = side_a.get_numbers_from_list()
if len(endpoint_num_list) != 2:
print '\nErr: incorrect number of numbers returned in endpoint list'
return False
if (endpoint_num_list[0] != a_num) or (endpoint_num_list[1] != b_num):
print '\nErr: incorrect numbers returned in endpoint list'
return False
# make endpoint calls on all endpoints in the list (ie, sideA and
# sideB) and test that their values are what should be expected
# for sidea's and sideb's internal numbers
endpoint_num_map = side_a.get_numbers_from_map()
if len(endpoint_num_map) != 2:
print '\nErr: incorrect number of numbers returned in endpoint map'
return False
if (a_index not in endpoint_num_map) or (b_index not in endpoint_num_map):
print '\nErr: missing indices in endpoint number map'
return False
if (endpoint_num_map[a_index] != a_num) or (endpoint_num_map[b_index] != b_num):
print '\nErr: incorrect values returned in endpoint map'
return False
return True
def run_test():
new_peered_num = 30
new_end_text = "hoi"
sideA, sideB = Waldo.same_host_create(SideA, new_peered_num).same_host_create(SideB, new_end_text)
if sideB.read_peered_num() != new_peered_num:
print "\nErr: B has incorrect peered number"
return False
if sideA.read_peered_num() != new_peered_num:
print "\nErr: A has incorrect peered number"
return False
if sideA.read_b_text() != new_end_text:
print "\nErr: A read incorrect text from B"
return False
return True
def run_test():
sideA, sideB = Waldo.same_host_create(SideA).same_host_create(SideB)
# assign endpoint into a
sideA.assign_endpoint(sideB)
# check to ensure that one side can make an endpoint call to the
# other side and receive a result.
base_num = 20
increment_num = 30
if sideA.test_assigned_number(base_num,increment_num) != (base_num+increment_num):
print '\nErr: with basic endpoint call'
return False
if sideA.check_value_type_argument(base_num,increment_num) != (base_num,base_num+increment_num):
print '\nErr: incorrectly modified value type data'
return False
# Test to ensure that passing an external variable through an
# endpoint call can change its value.
original_num = 32
ext_num = Waldo._waldo_classes['WaldoExtNumVariable'](
'garbage',sideA._host_uuid,False,original_num)
sideA.assign_external_number(ext_num)
new_num = 50
if sideA.test_updated_val(new_num) != new_num:
print '\nErr: external should have global change'
return False
# test that lists and maps are copied across endpoint calls
original_list = ['eiof','ff','efeio']
if sideA.hide_list(original_list) != len(original_list):
print '\nErr: list passed by reference across endpoint call'
return False
return True
def run_test():
sideA, sideB = (
Waldo.same_host_create(SideA,num_func).same_host_create(SideB,num_func))
for i in range(0,20):
sideA.run_signal(i)
sideA.service_signal()
time.sleep(.1)
sideB.service_signal()
time.sleep(.1)
try:
for j in range(0,2):
read_num = num_queue.get_nowait()
if (read_num != i) and (read_num != (i+1)):
print '\nUnexpected num read from queue\n'
return False
except Queue.Empty:
print '\nNever received signal to execute\n'
return False
return True
def run_test():
sideA,sideB = Waldo.same_host_create(SideA).same_host_create(SideB)
initial_val = 22
# check peered value is initialized properly
if sideA.read_peered_num() != initial_val:
print '\nErr: incorrect initial val of peered num on SideA'
return False
if sideB.read_peered_num() != initial_val:
print '\nErr: incorrect initial val of peered num on SideB'
return False
#### Testing that when send a 2-long sequence message, both sides update peered
#### value
NUM_BASIC_EXCHANGES = 20
for i in range(0,NUM_BASIC_EXCHANGES):
# when we initiate a basic sequence, peered number should end up
# +2 of what it was before it started.
expected_new_val = initial_val + (i+1)*2
if sideA.basic_exchange_test() != expected_new_val:
err_msg = '\nErr: incorrect value after basic message '
err_msg += 'seq on peered data'
print err_msg
return False
if sideB.read_peered_num() != expected_new_val:
err_msg = '\nErr: B did not receive updated peered '
err_msg += 'data from basic message seq'
print err_msg
return False
#### Now testing a longer sequence message. Also ends on where we started
val_after_basics = expected_new_val
NUM_EXTENDED_EXCHANGES = 20
for i in range(0,NUM_EXTENDED_EXCHANGES):
# when we initiate a basic sequence, peered number should end up
# +2 of what it was before it started.
expected_new_val = val_after_basics + (i+1)*28
# gotten_val = sideA.extended_exchange_test()
# import pdb
# pdb.set_trace()
if sideA.extended_exchange_test() != expected_new_val:
err_msg = '\nErr: incorrect value after ext message '
err_msg += 'seq on peered data'
print err_msg
return False
if sideB.read_peered_num() != expected_new_val:
err_msg = '\nErr: B did not receive updated peered '
err_msg += 'data from ext message seq'
print err_msg
return False
return True
def run_test():
sideA, sideB = Waldo.same_host_create(SideA).same_host_create(SideB)
initial_num = 22
initial_text = "a"
initial_tf = True
# check that peereds are initialized properly on both ends
if sideA.read_peered_value_types() != (initial_num, initial_text, initial_tf):
print "\nErr: incorrect initial val of peered on SideA"
return False
if sideB.read_peered_value_types() != (initial_num, initial_text, initial_tf):
print "\nErr: incorrect initial val of peered on SideB"
return False
#### Testing that when send a 2-long sequence message, both sides
#### can read peered args.
NUM_ARGUMENTS_CHECK_EXCHANGE = 20
expected_new_text = initial_text
expected_new_num = initial_num
expected_tf = initial_tf
for i in range(0, NUM_ARGUMENTS_CHECK_EXCHANGE):
# the values that we expect to be returned
expected_new_num += i
expected_new_text += "b"
expected_tf = (i % 2) == 0
if sideA.arguments_check(i, "b", expected_tf) != (expected_new_num, expected_new_text, expected_tf):
err_msg = "\nErr: incorrect value types after argument "
err_msg += "check message seq"
print err_msg
return False
if sideB.read_peered_value_types() != (expected_new_num, expected_new_text, expected_tf):
err_msg = "\nErr: B has incorrect value types after argument "
err_msg += "check message seq"
print err_msg
return False
#### Testing that can return values from sequence
NUM_RETURNS_CHECK_EXCHANGE = 20
for i in range(0, NUM_RETURNS_CHECK_EXCHANGE):
expected_returned_num = 55
expected_returned_text = "sideA"
expected_returned_tf = True
if sideA.returns_check() != (expected_returned_num, expected_returned_text, expected_returned_tf):
err_msg = "\nErr: A got incorrect returns while "
err_msg += "in returns check."
print err_msg
return False
#### Testing that can declare and manipulate sequence local
#### data not in arguments or return nodes
expecting_seq_local_num = 62
expecting_seq_local_text = "wowwow"
if (expecting_seq_local_num, expecting_seq_local_text) != sideA.non_arg_return_seq_local_data_check():
err_msg = "\nErr: A could not declare and manipulate "
err_msg += "additional sequence local data."
print err_msg
return False
#### Test to ensure that sequence local data do not affect
if not sideA.arguments_check_references():
err_msg = "\nErr: incorrect behavior for references"
print err_msg
return False
#### Test to ensure that returned reference types from sequences
#### get translated into non-peered.
if not sideA.returns_check_references():
err_msg = "\nErr: incorrect references returned from message sequence"
print err_msg
return False
# test that when we call a sequence that can access the element of
# a reference list
lister = [93, 3, 5, 68, 3]
index = 3
if sideA.return_reference_index(lister, index) != lister[index]:
err_msg = "\nErr: could not get element from lilst "
err_msg += "returned by sequence."
print err_msg
return False
# previously had some problems reading elements from copied
# maps/lists in the middle of a sequence. This tests to ensure
# that do not still have problem.
to_test_list = [({"a": 39, "b": 22, "c": 91}, 39), ({"oifjef": 3, "b": 22, "c": 91}, 1)]
for to_test in to_test_list:
map_to_test = to_test[0]
increment_to_test = to_test[1]
returned_val = sideA.plus_equals_on_map_check(map_to_test, increment_to_test)
expected_val = plus_equals_on_map(map_to_test, increment_to_test)
if returned_val != expected_val:
print "\nErr: in sequence map increment."
return False
return True
