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))