def run_test(): lhs = SingleSide() rhs = SingleSide() lhs_event = lhs.new_event() rhs_event = rhs.new_event() # make a change to lhs' number and try to update rhs' number. # ensure they can both commit the change. lhs.number.write_val(lhs_event,2) serializabled = lhs.number.serializable_var_tuple_for_network( 'some_name',lhs_event) waldoNetworkSerializer.deserialize_peered_object_into_variable( rhs._host_uuid,serializabled,rhs_event,rhs.number) if not lhs_event.hold_can_commit(): print '\nError: should be able to commit lhs.\n' return False lhs_event.complete_commit() if not rhs_event.hold_can_commit(): print '\nError: should be able to commit rhs.\n' return False rhs_event.complete_commit() # check that both sides have the new number lhs_event = lhs.new_event() rhs_event = rhs.new_event() if lhs.number.get_val(lhs_event) != 2: print '\nErr: for some reason, did not commit on lhs.\n' return False if rhs.number.get_val(rhs_event) != 2: print '\nErr: for some reason, did not commit on rhs.\n' return False if not lhs_event.hold_can_commit(): print '\nError: should be able to commit lhs second time.\n' return False lhs_event.complete_commit() if not rhs_event.hold_can_commit(): print '\nError: should be able to commit rhs second time.\n' return False rhs_event.complete_commit() return True
def run_test(): lhs = SingleSide() rhs = SingleSide() # lhs_event = lhs.new_event() rhs_event = rhs.new_event() internal_list1, evt = create_waldo_list(lhs, [1, 2, 3]) internal_list2, evt = create_waldo_list(lhs, [4, 5, 6], evt) internal_list3, evt = create_waldo_list(lhs, [7, 8, 9], evt) lhs.map.get_val(evt).add_key(evt, 1, internal_list1) lhs.map.get_val(evt).add_key(evt, 2, internal_list2) lhs.map.get_val(evt).add_key(evt, 1, internal_list3) # should produce: # { 1: [7,8,9], 2: [4,5,6] } serializabled = lhs.map.serializable_var_tuple_for_network("some_name", evt) waldoNetworkSerializer.deserialize_peered_object_into_variable(rhs._host_uuid, serializabled, rhs_event, rhs.map) if not evt.hold_can_commit(): print "\nError: should be able to commit lhs.\n" return False evt.complete_commit() if not rhs_event.hold_can_commit(): print "\nError: should be able to commit rhs.\n" return False rhs_event.complete_commit() # now check that cannot do operations in parallel that affect each # other. lhs_event will read all values in the map (and ensure # that they were set correctly from above). It also sets one # value. "concurrently" rhs_event1 will delete a value from its # map. similarly, rhs_event2 will try to apply the change made # from lhs_event. Should either be able to commit # {lhs_event,rhs_event2} or {rhs_event1}, but not both sets. lhs_event = lhs.new_event() rhs_event1 = rhs.new_event() rhs_event2 = rhs.new_event() if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 1).get_val(lhs_event).get_val_on_key(lhs_event, 0) != 7: print "\nErr: did not get change from previous commit.\n" return False if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_val_on_key(lhs_event, 0) != 4: print "\nErr: did not get change from previous commit 2.\n" return False lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).write_val_on_key(lhs_event, 0, 20) serializabled = lhs.map.serializable_var_tuple_for_network("some_name", lhs_event) waldoNetworkSerializer.deserialize_peered_object_into_variable(rhs._host_uuid, serializabled, rhs_event2, rhs.map) rhs.map.get_val(rhs_event1).del_key_called(rhs_event1, 1) if not rhs_event1.hold_can_commit(): print "\nError: should be able to commit delete" return False rhs_event1.complete_commit() if rhs_event2.hold_can_commit(): err_msg = "\nError: should not be able to commit rhs's " err_msg += "read+single write update after committed delete\n" return False rhs_event2.backout_commit() lhs_event.hold_can_commit() lhs_event.backout_commit() # should produce: # { 2: [4,5,6] } # now check that can do operations in parallel that do not affect # each other. lhs_event sets one value. "concurrently" rhs_event1 # deletes a different value from its map. rhs_event2 will try to # apply the change made from lhs_event. Should either be able to # commit all events. lhs_event2 will try to commit the change # made by rhs_event1 lhs_event1 = lhs.new_event() lhs_event2 = lhs.new_event() rhs_event1 = rhs.new_event() rhs_event2 = rhs.new_event() lhs.map.get_val(lhs_event1).get_val_on_key(lhs_event1, 2).get_val(lhs_event1).write_val_on_key(lhs_event1, 1, 16) rhs.map.get_val(rhs_event1).get_val_on_key(rhs_event1, 2).get_val(rhs_event1).del_key_called(rhs_event1, 2) serializabled = lhs.map.serializable_var_tuple_for_network("some_name", lhs_event1) waldoNetworkSerializer.deserialize_peered_object_into_variable(rhs._host_uuid, serializabled, rhs_event2, rhs.map) serializabled = rhs.map.serializable_var_tuple_for_network("some_name", rhs_event1) waldoNetworkSerializer.deserialize_peered_object_into_variable(lhs._host_uuid, serializabled, lhs_event2, lhs.map) if not lhs_event1.hold_can_commit(): print "\nError: should be able to commit lhs's write.\n" return False lhs_event1.complete_commit() if not rhs_event1.hold_can_commit(): print "\nError: should be able to commit rhs's delete.\n" return False rhs_event1.complete_commit() if not rhs_event2.hold_can_commit(): print "\nError: rhs_evt1 and rhs_evt2 should be able to commit in parallel.\n" return False rhs_event2.complete_commit() if not lhs_event2.hold_can_commit(): print "\nError: should be able to commit the rhs change on lhs2.\n" return False lhs_event2.complete_commit() # should produce: # { 2: [4,16] } # check to ensure that both sides saw the changes from above lhs_event = lhs.new_event() rhs_event = rhs.new_event() if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_val_on_key(lhs_event, 1) != 16: print "\nError: lhs_event should have seen updated value of 16.\n" return False if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_len(lhs_event) != 2: print "\nError: lhs_event should know that it contains a list of length 2.\n" return False if rhs.map.get_val(rhs_event).get_val_on_key(rhs_event, 2).get_val(rhs_event).get_val_on_key(rhs_event, 1) != 16: print "\nError: rhs_event should have seen updated value of 16.\n" return False if rhs.map.get_val(rhs_event).get_val_on_key(rhs_event, 2).get_val(rhs_event).get_len(rhs_event) != 2: print "\nError: rhs_event should know that it contains a list of length 2.\n" return False # should produce: # { 2: [4,16] } # another check that can do operations in parallel. lhs_event # will read all values in the map (and ensure that they were set # correctly from above). It also sets one value. "concurrently" # rhs_event1 will delete a value from its map. similarly, # rhs_event2 will try to apply the change made from lhs_event. # Should be able to commit {lhs_event, rhs_event2} and then # {rhs_event1}. lhs_event = lhs.new_event() rhs_event1 = rhs.new_event() rhs_event2 = rhs.new_event() if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_val_on_key(lhs_event, 0) != 4: print "\nErr: did not get change from previous commit.\n" return False if lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).get_val_on_key(lhs_event, 1) != 16: print "\nErr: did not get change from previous commit 2.\n" return False lhs.map.get_val(lhs_event).get_val_on_key(lhs_event, 2).get_val(lhs_event).write_val_on_key(lhs_event, 1, 20) serializabled = lhs.map.serializable_var_tuple_for_network("some_name", lhs_event) waldoNetworkSerializer.deserialize_peered_object_into_variable(rhs._host_uuid, serializabled, rhs_event2, rhs.map) int_l, evtl = create_waldo_list(rhs, [1, 2, 3]) if not evtl.hold_can_commit(): print "\nError: should be able to append to list" return False evtl.complete_commit() rhs.map.get_val(rhs_event1).add_key(rhs_event1, 1, int_l) if not rhs_event1.hold_can_commit(): print "\nError: should be able to commit add" return False rhs_event1.complete_commit() if not rhs_event2.hold_can_commit(): err_msg = "\nError: should not be able to commit rhs's " err_msg += "read+single write update in parallel with add\n" return False rhs_event2.complete_commit() if not lhs_event.hold_can_commit(): err_msg = "\nError: should not be able to commit lhs's " err_msg += "read+single write update in parallel with add\n" return False lhs_event.complete_commit() return True