Python Waldo.same_host_create方法代码示例

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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()

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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()

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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
#.........这里部分代码省略.........

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import same_host_create [as 别名]
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