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))
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
gotten_val = sideA.get_partner_struct(in_val)
if gotten_val != in_val:
# if sideA.get_partner_struct(in_val) != in_val:
print '\nErr: getting struct from partner'
print gotten_val
print in_val
print '\n\n'
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(A).same_host_create(B))
index = 'hi'
val = 30
if sideA.map_test(index, val) != val:
return False
# val = 30
# if sideA.struct_test(val) != val:
# return False
return True
def run_test():
sideA, sideB = (
Waldo.same_host_create(A).same_host_create(B))
index = 'hi'
val = 30
if sideA.map_test(index,val) != val:
return False
# val = 30
# if sideA.struct_test(val) != val:
# return False
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():
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():
sideA, sideB = (Waldo.same_host_create(SideA).same_host_create(SideB))
original_num = 30
ext_num = Waldo._waldo_classes['WaldoExtNumVariable'](sideA._host_uuid,
False, original_num)
sideA.load_ext_num(ext_num)
# sequences + externals
amt_to_increment = 6
a, b = sideA.test_seq_arg(amt_to_increment)
if a != (b + amt_to_increment):
print '\nErr: incorrect numbers from sequence'
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():
# connect endpoints to each other
side_a, side_b=(
Waldo.same_host_create(SideA,delay).same_host_create(SideB,delay))
# print '\n\n'
# print 'A: ' + str(side_a)
# print 'B: ' + str(side_b)
# print '\n\n'
# start events on each endpoint
all_as = start_endpt(side_a,SIDE_A_RESULT)
all_bs = start_endpt(side_b,SIDE_B_RESULT)
# wait until all events have finished
map ( lambda x: x.join(), all_as)
map ( lambda x: x.join(), all_bs)
return check_result_queue()
def run_test():
# connect endpoints to each other
side_a, side_b=(
Waldo.same_host_create(SideA,delay).same_host_create(SideB,delay))
# start events on each endpoint
global result_queue_one, result_queue_two
all_as_one = start_endpt(side_a,SIDE_A_RESULT_ONE,result_queue_one)
all_bs_one = start_endpt(side_b,SIDE_B_RESULT_ONE,result_queue_one)
all_as_two = start_endpt(side_a,SIDE_A_RESULT_TWO,result_queue_two)
all_bs_two = start_endpt(side_b,SIDE_B_RESULT_TWO,result_queue_two)
all_events = all_as_one + all_bs_one + all_as_two + all_bs_two
# wait until all events have finished
map ( lambda x: x.join(), all_events)
return check_result_queue()
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'](
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).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'](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).same_host_create(SideB))
original_num = 30
ext_num = Waldo._waldo_classes['WaldoExtNumVariable'](
'garbage',sideA._host_uuid,False,original_num)
sideA.load_ext_num(ext_num)
# sequences + externals
amt_to_increment = 6
a,b = sideA.test_seq_arg(amt_to_increment)
if a != (b + amt_to_increment):
print '\nErr: incorrect numbers from sequence'
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,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_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
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
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)
read_value = data_reader.read_inner_map(index)
# if data_reader.read_inner_map(index) != inner_map_to_add:
if read_value != inner_map_to_add:
print '\n\n'
print index
print read_value
print '\nErr: problem with updating peered nested map'
return False
# here is what i think the bug is: the update for with the internal list is not getting sent to other side.
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():
single_side, ow = Waldo.same_host_create(one_side).same_host_create(other_side)
single_side.single_string()
single_side.do_it(ow);
time.sleep(5)
return True
