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