def test_share_bases(self):
cac = CACMock(expected_sent=[0, 0, 1, 1], received_data=[0, 1, 0, 1])
node = self.make_node(cac)
node._qstates = [QState(1, 0), QState(1, 0), QState(0, 1), QState(1, 1)]
node._share_bases()
self.assertSequenceEqual([0, 1, 0, 1], node._other_bases)
self.assertTrue(cac.send_was_called)
def test_sending_qubits_with_default_bases(self):
self.qc.send_qubits(
[QState(0, 0),
QState(0, 1),
QState(1, 0),
QState(1, 1)])
self.assert_qubit_operations([], ['H'], ['X'], ['X', 'H'])
def test_send_amplification_seed(self):
random.seed(42)
cac = CACMock(expected_sent=[0, 0, 1])
node = self.make_node(cac)
node._qstates = [QState(1, 0), QState(1, 0), QState(0, 0), QState(1, 0), QState(0, 0)]
node._test_set = {0, 2}
node._send_seed()
self.assertSequenceEqual([0, 0, 1], node._seed)
self.assertTrue(cac.send_was_called)
def test_receiving_epr_pair(self):
self.con.received_qubits = [
QubitSpy(0), QubitSpy(0),
QubitSpy(1), QubitSpy(1)
]
self.assertSequenceEqual(
[QState(0, 0),
QState(0, 1),
QState(1, 0),
QState(1, 1)], self.qc.receive_epr_in([0, 1, 0, 1]))
def test_send_test_values(self):
self.node._qstates = [
QState(1, 0),
QState(1, 0),
QState(0, 0),
QState(1, 0)
]
self.node._test_set = {0, 2}
self.node._send_test_values()
self.assertSequenceEqual([1, 0], self.cac.data_sent)
def test_privacy_amplification_odd(self):
self.node._qstates = [
QState(1, 0),
QState(1, 0),
QState(0, 0),
QState(1, 0),
QState(1, 0)
]
self.node._raw_key_set = {1, 3, 4}
self.node._seed = [1, 1, 1]
self.assertEqual([1], self.node._privacy_amplification())
def test_privacy_amplification_even(self):
self.node._qstates = [
QState(1, 0),
QState(1, 0),
QState(0, 0),
QState(1, 0),
QState(1, 0)
]
self.node._test_set = {0, 2}
self.node._seed = [1, 1, 0]
self.assertEqual([0], self.node._privacy_amplification())
def test_calculate_win_probability(self):
self.node._qstates = [
QState(1, 0),
QState(0, 1),
QState(1, 1),
QState(0, 1),
QState(0, 0)
]
self.node._chsh_test_values = [1, 0, 1, 0]
self.node._other_chsh_test_values = [1, 1, 0, 0]
self.node._other_bases = [1, 1, 0, 0, 0]
self.node._chsh_test_set = {0, 1, 2, 3}
self.assertAlmostEqual(0.75,
self.node._calculate_winning_probability())
def test_send_test_set(self):
random.seed(7)
cac = CACMock(expected_sent=[0, 1, 2, 5, 6, 8, 10])
node = self.make_node(cac)
node._qstates = [QState(1, 0)] * 15
node._send_test_set()
self.assertTrue(cac.send_was_called)
def _send_q_states(self, amount):
super()._send_q_states(amount)
self._qstates = [
QState(value, basis)
for value, basis in zip(self._gen_random_string(amount),
self._gen_random_string(amount))
]
self.q_channel.send_qubits(self._qstates)
def test_maximize_key_bit_extraction_with_errors(self):
node = self.make_node(None)
node.maximize_key_bits = True
node._qstates = [QState(1, 0)] * 6
node._seed = [1] * 6
node._calculate_matching_error_of_values([1] * 6, [1, 1, 1, 0, 0, 0])
key = node._calc_privacy_amplification_of({0, 1, 2, 3, 4, 5})
self.assertEqual([0, 0, 0], key)
def test_subset_separation(self):
self.node._other_bases = [1, 0, 0, 0, 1, 0]
self.node._test_set = {0, 1, 2}
self.node._qstates = [
QState(1, 1),
QState(0, 0),
QState(1, 2),
QState(0, 0),
QState(1, 1),
QState(0, 2)
]
self.node._separate_test_subsets()
self.assert_test_sets(expected_chsh={0, 1},
expected_match={2},
expected_raw_key={5})
def test_extract_single_bit_default(self):
node = self.make_node(None)
node._qstates = [QState(1, 0)] * 4
node._seed = [1, 1, 1]
key = node._calc_privacy_amplification_of({0, 1, 2})
self.assertEqual([1], key)
def test_measuring_sent_epr_pair(self):
self.con.epr_values = deque([1, 0])
self.assertEqual([QState(1, 0), QState(0, 1)], self.qc.send_epr([0,
1]))
def test_sending_qubits_with_specified_bases(self):
self.qc.bases_mapping = [lambda q: q.Z(), lambda q: q.Y()]
self.qc.send_qubits([QState(0, 0), QState(0, 1)])
self.assert_qubit_operations(['Z'], ['Y'])
def test_send_qubits_to_receiver(self):
self.qc.send_qubits([QState(0, 0)])
self.assertEqual('Bob', self.con.receiver)
def test_discard_invalid_states(self):
self.node._other_bases = [1, 1, 0, 0]
self.node._qstates = [QState(1, 0)] * 4
self.node._discard_states()
self.assertSequenceEqual([QState(1, 0)] * 2, self.node._qstates)
def test_receiving_q_states(self):
self.cac.received = [3]
self.qc.received = [QState(1, 0), QState(1, 1), QState(0, 0)]
self.node._receive_q_states()
self.assertSequenceEqual(self.qc.received, self.node._qstates)
self.assertEqual(3, len(self.qc.requested_bases))