def testSendGetStateAndEnergyRequest(self):
self._setUpExchangeMaster(MockCommunicator())
self._remaster._send_get_state_and_energy_request(self._replica_names[0],
self._replica_names[1])
(last_sent, last_dest) = self._comm.sent.pop()
self._checkGetStateAndEnergyRequest(last_sent,
self._replica_names[1],
self._replica_names[0])
def testAcceptBufferedProposal(self):
from rexfw.remasters.requests import AcceptBufferedProposalRequest
for accepted in (True, False):
self._replica = ProposeMockReplica(MockCommunicator())
req = AcceptBufferedProposalRequest(self._replica._current_master,
accepted)
self._replica._accept_buffered_proposal(req)
self._checkAcceptBufferedProposal(accepted)
def testPropose(self):
from rexfw.test.cases.replicas import CalculateProposalMockReplica
replica = CalculateProposalMockReplica(MockCommunicator())
result = self._proposer.propose(replica, 4.2, 8.9, None)
self.assertTrue(isinstance(result, GeneralTrajectory))
self.assertEqual(result[0], 4.2)
self.assertEqual(result[-1], 4.2)
self.assertEqual(result.work, 42 - 8.9)
def testSendSampleRequests(self):
self._setUpExchangeMaster(MockCommunicator())
self._remaster._send_sample_requests(self._replica_names)
sent_objs = self._remaster._comm.sent
for r in self._replica_names:
obj, _ = sent_objs.popleft()
self._checkParcel(obj, r, self._remaster.name)
self._checkSendSampleRequest(obj.data, self._remaster.name)
def testGetNoExReplicas(self):
self._setUpExchangeMaster(MockCommunicator())
for step in (0, 1):
swap_list = self._remaster._calculate_swap_list(step)
no_exchange = self._remaster._get_no_ex_replicas(swap_list)
self.assertEqual(len(no_exchange), 1)
self.assertEqual(no_exchange[0], self._replica_names[2] if step == 0
else self._replica_names[0])
def testTerminateReplicas(self):
self._setUpExchangeMaster(MockCommunicator())
self._remaster.terminate_replicas()
sent_objs = self._remaster._comm.sent
for r in self._replica_names:
obj, _ = sent_objs.popleft()
self._checkParcel(obj, r, self._remaster.name)
self._checkDieRequest(obj.data, self._remaster.name)
def testSendRejectExchangeRequest(self):
self._setUpExchangeMaster(MockCommunicator())
for step in (0,1):
swap_list = self._remaster._calculate_swap_list(step)
for r1, r2, _ in swap_list:
for r in (r1, r2):
self._remaster._send_reject_exchange_request(r)
sent_obj, _ = self._remaster._comm.sent[-1]
self._checkAcceptBufferedProposalRequest(sent_obj, r, False)
def testWriteStatistics(self):
self._setUpExchangeMaster(MockCommunicator())
self._remaster._write_statistics(123)
write_stack = self._remaster.sampling_statistics.write_stack
self.assertEqual(len(write_stack), 1)
self.assertEqual(write_stack.pop(), 123)
write_stack = self._remaster.swap_statistics.write_stack
self.assertEqual(len(write_stack), 1)
self.assertEqual(write_stack.pop(), 123)
def testSendProposeRequest(self):
from rexfw.slgenerators import ExchangeParams
self._setUpExchangeMaster(MockCommunicator())
self._remaster._send_propose_request(self._replica_names[0],
self._replica_names[1],
ExchangeParams([],[]))
(last_sent, last_dest) = self._comm.sent.pop()
self._checkProposeRequest(last_sent, self._replica_names[0],
self._replica_names[1])
def testReceiveAndUpdateStats(self):
self._setUpExchangeMaster(MockCommunicator())
self._remaster._receive_and_update_stats(self._replica_names)
recvd_objs = self._remaster._comm.received
for r in self._replica_names:
obj, source = recvd_objs.popleft()
self._checkParcel(obj, self._remaster.name, r)
self.assertEqual(source, r)
update = self._remaster.sampling_statistics.update_stack.popleft()
self.assertTrue(update[0] is None)
self.assertEqual(len(update[1]), 1)
self.assertEqual(update[1][0], r)
def testPropose(self):
from rexfw.remasters import ProposeRequest
from rexfw.slgenerators import ExchangeParams
from rexfw.proposers.params import REProposerParams
self._replica = ProposeMockReplica(MockCommunicator())
req = ProposeRequest(
'remaster34', 'replica22',
ExchangeParams(['mock_proposer1', 'mock_proposer2'],
REProposerParams()))
self._replica._propose(req)
self.assertTrue(self._replica.works_heats_sent)
self.assertEqual(self._replica._buffered_proposal, 4)
def testSendDumpSamplesRequest(self):
self._setUpExchangeMaster(MockCommunicator())
folder = 'bla'
smin, smax = 1, 2
offset = 3
dump_step = 4
self._remaster._send_dump_samples_request(smin, smax, offset, dump_step)
sent_objs = self._remaster._comm.sent
for r in self._replica_names:
obj, _ = sent_objs.popleft()
self._checkParcel(obj, r, self._remaster.name)
self._checkSendDumpSamplesRequest(obj.data, self._remaster.name,
folder, smin, smax, offset,
dump_step)
def testTriggerProposalCalculation(self):
self._setUpExchangeMaster(MockCommunicator())
for step in (0, 1):
swap_list = self._remaster._calculate_swap_list(step)
swap = swap_list[-1]
r1 = swap[0]
r2 = swap[1]
params = swap[2]
self._remaster._trigger_proposal_calculation(swap_list)
params = swap[2]
self._checkGetStateAndEnergyRequest(self._comm.sent.popleft()[0],
r2, r1)
self._checkGetStateAndEnergyRequest(self._comm.sent.popleft()[0],
r1, r2)
self._checkProposeRequest(self._comm.sent.popleft()[0],
r1, r2)
self._checkProposeRequest(self._comm.sent.popleft()[0],
r2, r1)
self.assertEqual(params.proposer_params.reverse_events, 2)
def testCalculateProposal(self):
from rexfw.remasters import ProposeRequest
from rexfw.slgenerators import ExchangeParams
from rexfw.proposers import GeneralTrajectory
from rexfw.proposers.params import REProposerParams
self._replica = CalculateProposalMockReplica(MockCommunicator())
req = ProposeRequest(
'remaster34', 'replica22',
ExchangeParams(['mock_proposer1', 'mock_proposer2'],
REProposerParams()))
result = self._replica._calculate_proposal(req)
self.assertEqual(self._replica.pick_proposer_called, 1)
self.assertEqual(
self._replica.proposers['mock_proposer1'].partner_name,
'replica22')
self.assertTrue(isinstance(result, GeneralTrajectory))
self.assertEqual(result[:], [0, 1])
self.assertEqual(result.heat, 0)
self.assertEqual(result.work, 0)
def testEnergy(self):
self._replica = CalculateProposalMockReplica(MockCommunicator())
self.assertEqual(self._replica.energy, 42)
def setUp(self):
self._replica = MockReplica(MockCommunicator())
