def main(): backend = CQCBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) network.delay = 0.0 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) q = Qubit(hosts['alice']) q.X() hosts['alice'].send_teleport(hosts['bob'].host_id, q) q2 = hosts['bob'].get_data_qubit(hosts['alice'].host_id) i = 0 while q2 is None and i < 5: q2 = hosts['bob'].get_data_qubit(hosts['alice'].host_id) i += 1 time.sleep(1) assert q2 is not None assert q2.measure() == 1 print("All tests succesfull!") network.stop(True) exit()
def main(): backend = EQSNBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) network.delay = 0.0 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) ack_received_1 = hosts['alice'].send_classical(hosts['bob'].host_id, 'hello bob one', await_ack=True) hosts['alice'].max_ack_wait = 0.0 ack_received_2 = hosts['alice'].send_classical(hosts['bob'].host_id, 'hello bob one', await_ack=True) assert ack_received_1 assert not ack_received_2 print("All tests succesfull!") network.stop(True) exit()
def main(): network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] backend = CQCBackend() network.start(nodes, backend) network.delay = 0.7 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} network.delay = 0 # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) q1 = Qubit(hosts['alice']) hosts['alice'].send_qubit('Bob', q1, await_ack=True) q1 = Qubit(hosts['alice']) hosts['alice'].send_qubit('Bob', q1, await_ack=True) q1 = Qubit(hosts['alice']) hosts['alice'].send_qubit('Bob', q1, await_ack=True) q1 = Qubit(hosts['bob']) hosts['bob'].send_qubit('Alice', q1, await_ack=True) network.stop(True) exit()
def main(): network = Network.get_instance() # backend = ProjectQBackend() backend = CQCBackend() nodes = ['A', 'B', 'C'] network.start(nodes, backend) network.delay = 0.1 host_A = Host('A', backend) host_A.add_connection('B') host_A.delay = 0 host_A.start() host_B = Host('B', backend) host_B.add_connections(['A', 'C']) host_B.delay = 0 host_B.start() host_C = Host('C', backend) host_C.add_connection('B') host_C.delay = 0 host_C.start() network.add_host(host_A) network.add_host(host_B) network.add_host(host_C) t1 = host_A.run_protocol(protocol_1, (host_C.host_id, )) t2 = host_C.run_protocol(protocol_2, (host_A.host_id, )) t1.join() t2.join() network.stop(True)
def main(): # Initialize a network network = Network.get_instance() nodes = ['Alice', 'Bob', 'Eve'] network.delay = 0.0 network.start(nodes) host_alice = Host('Alice') host_alice.add_connection('Bob') host_alice.start() host_bob = Host('Bob') host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve') host_eve.add_connection('Bob') host_eve.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) print('Starting transfer') t1 = host_alice.run_protocol(banker_protocol, (host_eve.host_id, )) t2 = host_eve.run_protocol(customer_protocol, (host_alice.host_id, )) t1.join() t2.join() network.stop(True)
def main(): network = Network.get_instance() nodes = ['A', 'B', 'C'] network.start(nodes) network.delay = 0.1 host_A = Host('A') host_A.add_connection('B') host_A.start() host_B = Host('B') host_B.add_connection('A') host_B.add_connection('C') host_B.start() host_C = Host('C') host_C.add_connection('B') host_C.start() network.add_host(host_A) network.add_host(host_B) network.add_host(host_C) host_A.run_protocol(protocol_1, (host_C.host_id,)) host_C.run_protocol(protocol_2, (host_A.host_id,))
def main(): network = Network.get_instance() nodes = ['Alice', 'Bob', 'Eve'] network.delay = 0.2 network.start(nodes) host_alice = Host('Alice') host_bob = Host('Bob') host_eve = Host('Eve') host_alice.add_connection('Bob') host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_eve.add_connection('Bob') host_alice.start() host_bob.start() host_eve.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) q = Qubit(host_alice) q.X() host_alice.send_teleport('Eve', q, await_ack=True) q_eve = host_eve.get_data_qubit(host_alice.host_id, q.id, wait=5) assert q_eve is not None print('Eve measures: %d' % q_eve.measure())
def main(): network = Network.get_instance() network.delay = 0.1 nodes = ["Alice", "Bob", "Eve"] network.start(nodes) host_alice = Host('Alice', ) host_alice.add_connection('Bob') host_alice.start() host_bob = Host('Bob') host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve') host_eve.add_connection('Bob') host_eve.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) host_alice.send_superdense('Eve', '11') host_alice.send_superdense('Eve', '10') host_alice.send_superdense('Eve', '00') time.sleep(5) messages = host_eve.get_classical('Alice') for m in messages: print('----') print(m) print('----')
def main(): backend = CQCBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) network.delay = 0.7 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) hosts['alice'].send_superdense(hosts['bob'].host_id, '01') messages = hosts['bob'].classical i = 0 while i < 5 and len(messages) == 0: messages = hosts['bob'].classical i += 1 time.sleep(1) assert messages is not None assert len(messages) > 0 assert (messages[0].sender == hosts['alice'].host_id) assert (messages[0].content == '01') print("All tests succesfull!") network.stop(True) exit()
def main(): network = Network.get_instance() nodes = ["Alice", "Bob"] network.x_error_rate = 0 network.delay = 0.5 network.start(nodes) host_alice = Host('Alice') host_alice.add_connection('Bob') host_alice.max_ack_wait = 10 host_alice.delay = 0.2 host_alice.start() host_bob = Host('Bob') host_bob.max_ack_wait = 10 host_bob.delay = 0.2 host_bob.add_connection('Alice') host_bob.start() network.add_host(host_alice) network.add_host(host_bob) q_size = 6 host_alice.run_protocol(qudp_sender, (q_size, host_bob.host_id)) host_bob.run_protocol(qudp_receiver, (q_size, host_alice.host_id)) start_time = time.time() while time.time() - start_time < 50: pass network.stop(stop_hosts=True)
def main(): network = Network.get_instance() nodes = ["Alice", "Bob", "Eve"] network.start(nodes) network.delay = 0.1 host_alice = Host('Alice') host_alice.add_connection('Bob') host_alice.start() host_bob = Host('Bob') host_bob.add_connections(['Alice', 'Eve']) host_bob.start() host_eve = Host('Eve') host_eve.add_connection('Bob') host_eve.start() network.add_hosts([host_alice, host_bob, host_eve]) host_bob.q_relay_sniffing = True host_bob.q_relay_sniffing_fn = bob_sniffing_quantum host_bob.c_relay_sniffing = True host_bob.c_relay_sniffing_fn = bob_sniffing_classical t1 = host_alice.run_protocol(alice) t2 = host_eve.run_protocol(eve) t1.join() t2.join() network.stop(True) exit()
def main(): network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] back = ProjectQBackend() network.start(nodes, back) network.delay = 0.1 host_alice = Host('Alice', back) host_alice.add_connection('Bob') host_alice.add_connection('Eve') host_alice.start() host_bob = Host('Bob', back) host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve', back) host_eve.add_connection('Bob') host_eve.add_connection('Dean') host_eve.add_connection('Alice') host_eve.start() host_dean = Host('Dean', back) host_dean.add_connection('Eve') host_dean.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) network.add_host(host_dean) share_list = ["Bob", "Eve", "Dean"] q_id1 = host_alice.send_ghz(share_list, no_ack=True) q1 = host_alice.get_ghz('Alice', q_id1, wait=10) q2 = host_bob.get_ghz('Alice', q_id1, wait=10) q3 = host_eve.get_ghz('Alice', q_id1, wait=10) q4 = host_dean.get_ghz('Alice', q_id1, wait=10) if q1 is None: raise ValueError("Q1 is none") if q2 is None: raise ValueError("Q2 is none") if q3 is None: raise ValueError("Q3 is none") if q4 is None: raise ValueError("Q4 is none") m1 = q1.measure() m2 = q2.measure() m3 = q3.measure() m4 = q4.measure() print("results of measurements are %d, %d, %d, and %d." % (m1, m2, m3, m4)) network.stop(True) exit()
def main(): Y = 2 M = 2 network = Network.get_instance() nodes = ['Alice','C0','Bob'] network.use_ent_swap = True network.start(nodes) #0.01549 alice = Host('Alice') alice.add_connection('C0', 100) alice.coherence_time = 1 alice.max_ack_wait = 5 alice.start() repeater0 = Host('C0') repeater0.add_connection('Alice', 100) repeater0.add_connection('Bob', 100) repeater0.coherence_time = 1 repeater0.max_ack_wait = 5 repeater0.start() # repeater1 = Host('C1') # repeater1.add_connection('C0') # repeater1.add_connection('C2') # repeater1.max_ack_wait = 5 # repeater1.start() # repeater2 = Host('C2') # repeater2.add_connection('C1') # repeater2.add_connection('Bob') # repeater2.max_ack_wait = 5 # repeater2.start() bob = Host('Bob') bob.add_connection('C0', 100) bob.coherence_time = 1 bob.max_ack_wait = 5 bob.start() network.add_host(alice) network.add_host(repeater0) #network.add_host(repeater1) #network.add_host(repeater2) network.add_host(bob) t1 = alice.run_protocol(AliceProtocol, (repeater0.host_id, Y, M)) t2 = repeater0.run_protocol(RepeaterProtocol, (alice.host_id, bob.host_id, 0, 1, Y, M)) #repeater1.run_protocol(RepeaterProtocol, (repeater0.host_id, repeater2.host_id, 1, 2, Y, M)) #repeater2.run_protocol(RepeaterProtocol, (repeater1.host_id, bob.host_id, 2, 2, Y, M)) t3 = bob.run_protocol(BobProtocol, (repeater0.host_id, Y, M)) t1.join() t2.join() t3.join() network.stop(True)
def main(): # Initialize a network network = Network.get_instance() backend = EQSNBackend() # Define the host IDs in the network nodes = ['Alice', 'Bob'] network.delay = 0.0 # Start the network with the defined hosts network.start(nodes, backend) # Initialize the host Alice host_alice = Host('Alice', backend) # Add a one-way connection (classical and quantum) to Bob host_alice.add_connection('Bob') host_alice.delay = 0.0 # Start listening host_alice.start() host_bob = Host('Bob', backend) # Bob adds his own one-way connection to Alice host_bob.add_connection('Alice') host_bob.delay = 0.0 host_bob.start() # Add the hosts to the network # The network is: Alice <--> Bob network.add_host(host_alice) network.add_host(host_bob) # Generate random key key_size = 20 # the size of the key in bit secret_key = np.random.randint(2, size=key_size) # Concatentate functions def alice_func(alice): msg_buff = [] alice_qkd(alice, msg_buff, secret_key, host_bob.host_id) alice_send_message(alice, secret_key, host_bob.host_id) def bob_func(eve): msg_buff = [] eve_key = eve_qkd(eve, msg_buff, key_size, host_alice.host_id) eve_receive_message(eve, msg_buff, eve_key, host_alice.host_id) # Run Bob and Alice host_alice.run_protocol(alice_func, ()) host_bob.run_protocol(bob_func, (), blocking=True) time.sleep(1) network.stop(True)
def main(): network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes) network.delay = 0.5 host_alice = Host('Alice') host_alice.add_connection('Bob') host_alice.max_ack_wait = 30 host_alice.delay = 0.2 host_alice.start() host_bob = Host('Bob') host_bob.max_ack_wait = 30 host_bob.delay = 0.2 host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve') host_eve.max_ack_wait = 30 host_eve.delay = 0.2 host_eve.add_connection('Bob') host_eve.add_connection('Dean') host_eve.start() host_dean = Host('Dean') host_dean.max_ack_wait = 30 host_dean.delay = 0.2 host_dean.add_connection('Eve') host_dean.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) network.add_host(host_dean) network.x_error_rate = 0 network.packet_drop_rate = 0 q_size = 6 checksum_per_qubit = 2 host_alice.run_protocol(checksum_sender, (q_size, host_dean.host_id, checksum_per_qubit)) host_dean.run_protocol(checksum_receiver, (q_size, host_alice.host_id, checksum_per_qubit)) start_time = time.time() while time.time() - start_time < 150: pass network.stop(stop_hosts=True) exit()
def setUpClass(cls): simulaqron_settings.default_settings() nodes = ['Alice', 'Bob', 'Eve'] cls.sim_network = SimulaNetwork(nodes=nodes, force=True) cls.sim_network.start() cls.network = Network.get_instance() cls.network.start() if os.path.exists('./components/__pycache__'): os.system('rm -rf ./components/__pycache__/')
def test_adding_hosts_to_backend(backend_generator): print("Starrting adding a host test...") backend = backend_generator() network = Network.get_instance() network.start(["Alice"], backend) alice = Host('Alice', backend) alice.start() network.add_host(alice) network.stop(True) print("Test was successfull!")
def qunetsim(): from components.host import Host from components.network import Network from objects.qubit import Qubit network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes) network.delay = 0.1 host_alice = Host('Alice') host_alice.add_connection('Bob') host_alice.start() host_bob = Host('Bob') host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve') host_eve.add_connection('Bob') host_eve.add_connection('Dean') host_eve.start() host_dean = Host('Dean') host_dean.add_connection('Eve') host_dean.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) network.add_host(host_dean) from mappings.qunetsim import mapping #return host_alice, host_bob, host_eve, network def source_protocol(source_host, target_host_id): _ = qpz_atomics.lib(mapping, source_host) for i in range(5): q = _.PREP() q = _.H(q) print("sending"), _.DISP(q) _.SEND(q, target_host_id) def target_protocol(target_host, source_host_id): _ = qpz_atomics.lib(mapping, target_host) for i in range(5): print(source_host_id) q = _.RECV(source_host_id) print("recieved"), _.DISP(q) host_alice.run_protocol(source_protocol, (host_bob.host_id, )) host_bob.run_protocol(target_protocol, (host_alice.host_id, ))
def test_multiple_backends(backend_generator): print("Starting multiple backends test...") backend1 = backend_generator() backend2 = backend_generator() assert backend1._cqc_connections == backend2._cqc_connections network = Network.get_instance() network.start(["Alice", "Bob"], backend1) alice = Host('Alice', backend2) bob = Host('Bob', backend1) assert str(backend1._cqc_connections) == str(backend2._cqc_connections) assert str(backend1._hosts) == str(backend2._hosts) network.stop(True) print("Test was successfull!")
def main(): network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] backend = CQCBackend() network.start(nodes, backend) network.delay = 0.2 network.packet_drop_rate = 0 print('') host_alice = Host('Alice', backend) host_alice.add_connection('Bob') host_alice.start() host_bob = Host('Bob', backend) host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve', backend) host_eve.add_connection('Bob') host_eve.add_connection('Dean') host_eve.start() host_dean = Host('Dean', backend) host_dean.add_connection('Eve') host_dean.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) network.add_host(host_dean) print('alice sends message') host_alice.send_classical('Bob', 'hello1') host_alice.send_classical('Bob', 'hello2') host_alice.send_classical('Bob', 'hello3') host_alice.send_classical('Bob', 'hello4') host_alice.send_classical('Bob', 'hello5') host_alice.send_classical('Bob', 'hello6') host_alice.send_classical('Bob', 'hello7') host_alice.send_classical('Bob', 'hello8') host_alice.send_classical('Bob', 'hello9') host_alice.send_classical('Bob', 'hello10') start_time = time.time() while time.time() - start_time < 10: pass network.stop(True) exit()
def main(): global thread_1_return global thread_2_return network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes) network.delay = 0.5 host_alice = Host('alice') host_alice.add_connection('bob') host_alice.max_ack_wait = 30 host_alice.delay = 0.2 host_alice.start() host_bob = Host('bob') host_bob.max_ack_wait = 30 host_bob.delay = 0.2 host_bob.add_connection('alice') host_bob.add_connection('eve') host_bob.start() host_eve = Host('eve') host_eve.max_ack_wait = 30 host_eve.delay = 0.2 host_eve.add_connection('bob') host_eve.add_connection('dean') host_eve.start() host_dean = Host('dean') host_dean.max_ack_wait = 30 host_dean.delay = 0.2 host_dean.add_connection('eve') host_dean.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) network.add_host(host_dean) host_alice.run_protocol(retransmission_sender, (host_dean.host_id, MAX_TRIAL_NUM)) host_dean.run_protocol(retransmission_receiver, (host_alice.host_id, MAX_TRIAL_NUM)) start_time = time.time() while time.time() - start_time < 150: pass network.stop(stop_hosts=True) exit()
def main(): # Initialize a network network = Network.get_instance() # Define the host IDs in the network nodes = ['Alice', 'Bob', 'Eve'] network.delay = 0.0 # Start the network with the defined hosts network.start(nodes) # Initialize the host Alice host_alice = Host('Alice') # Add a one-way connection (classical and quantum) to Bob host_alice.add_connection('Bob') # Start listening host_alice.start() host_bob = Host('Bob') # Bob adds his own one-way connection to Alice and Eve host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve') host_eve.add_connection('Bob') host_eve.start() # Add the hosts to the network # The network is: Alice <--> Bob <--> Eve network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) # Generate random key key_size = 8 # the size of the key in bit hosts = {'Alice': host_alice, 'Bob': host_bob, 'Eve': host_eve} # Run Alice and Eve host_alice.send_key(host_eve.host_id, key_size) start_time = time.time() while time.time() - start_time < 60: pass print('SENDER KEYS') print(host_alice.qkd_keys) print('RECEIVER KEYS') print(host_eve.qkd_keys) for h in hosts.values(): h.stop() network.stop()
def main(): print("Skip test, this test has to be updated!") return backend = CQCBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) network.delay = 0.7 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} network.delay = 0 # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) # print(f"ack test - SEND CLASSICAL - started at {time.strftime('%X')}") hosts['alice'].send_classical(hosts['bob'].host_id, 'hello bob one', await_ack=True) hosts['alice'].send_classical(hosts['bob'].host_id, 'hello bob two', await_ack=True) # print(f"ack test - SEND CLASSICAL - finished at {time.strftime('%X')}") saw_ack_1 = False saw_ack_2 = False messages = hosts['alice'].classical # print([m.seq_num for m in messages]) for m in messages: if m.content == protocols.ACK and m.seq_num == 0: saw_ack_1 = True if m.content == protocols.ACK and m.seq_num == 1: saw_ack_2 = True if saw_ack_1 and saw_ack_2: break assert saw_ack_1 assert saw_ack_2 print("All tests succesfull!") network.stop(True) exit()
def main(): network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes) network.delay = 0.1 host_alice = Host('Alice') host_alice.add_connection('Bob') host_alice.start() host_bob = Host('Bob') host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve') host_eve.add_connection('Bob') host_eve.add_connection('Dean') host_eve.start() host_dean = Host('Dean') host_dean.add_connection('Eve') host_dean.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) network.add_host(host_dean) # Create a qubit owned by Alice q = Qubit(host_alice) # Put the qubit in the excited state q.X() # Send the qubit and await an ACK from Dean q_id, _ = host_alice.send_qubit('Dean', q, await_ack=True) # Get the qubit on Dean's side from Alice q_rec = host_dean.get_data_qubit('Alice', q_id) # Ensure the qubit arrived and then measure and print the results. if q_rec is not None: m = q_rec.measure() print("Results of the measurements for q_id are ", str(m)) else: print('q_rec is none') network.stop(True) exit()
def main(): network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes) network.delay = 0.1 host_alice = Host('Alice') host_alice.add_connection('Bob') host_alice.start() host_bob = Host('Bob') host_bob.add_connection('Alice') host_bob.add_connection('Eve') host_bob.start() host_eve = Host('Eve') host_eve.add_connection('Bob') host_eve.add_connection('Dean') host_eve.start() host_dean = Host('Dean') host_dean.add_connection('Eve') host_dean.start() network.add_host(host_alice) network.add_host(host_bob) network.add_host(host_eve) network.add_host(host_dean) q_id1, _ = host_alice.send_epr('Dean', await_ack=True) q1 = host_alice.get_epr('Dean', q_id1) q2 = host_dean.get_epr('Alice', q_id1) if q1 is not None and q2 is not None: m1 = q1.measure() m2 = q2.measure() print("Results of the measurements for the entangled pair are %d %d" % (m1, m2)) else: if q1 is None: print('q1 is none') if q2 is None: print('q2 is none') network.stop(True) exit()
def main(): backend = EQSNBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) network.delay = 0.7 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} network.delay = 0 # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) # send messages to Bob without waiting for ACKs hosts['alice'].send_classical(hosts['bob'].host_id, 'hello bob one', await_ack=False) hosts['alice'].send_classical(hosts['bob'].host_id, 'hello bob two', await_ack=False) hosts['alice'].send_classical(hosts['bob'].host_id, 'hello bob three', await_ack=False) hosts['alice'].send_classical(hosts['bob'].host_id, 'hello bob four', await_ack=False) # Wait for all Acks from Bob hosts['alice'].await_remaining_acks(hosts['bob'].host_id) saw_ack = [False, False, False, False] messages = hosts['alice'].classical for m in messages: if m.content == protocols.ACK: saw_ack[m.seq_num] = True for ack in saw_ack: assert ack print("All tests succesfull!") network.stop(True)
def main(): backend = CQCBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) network.delay = 0.7 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} network.delay = 0 # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) hosts['alice'].send_classical(hosts['bob'].host_id, 'Hello Bob', False) hosts['bob'].send_classical(hosts['alice'].host_id, 'Hello Alice', False) i = 0 bob_messages = hosts['bob'].classical while i < 5 and len(bob_messages) == 0: bob_messages = hosts['bob'].classical i += 1 time.sleep(1) i = 0 alice_messages = hosts['alice'].classical while i < 5 and len(alice_messages) == 0: alice_messages = hosts['alice'].classical i += 1 time.sleep(1) assert len(alice_messages) > 0 assert alice_messages[0].sender == hosts['bob'].host_id assert alice_messages[0].content == 'Hello Alice' assert (len(bob_messages) > 0) assert (bob_messages[0].sender == hosts['alice'].host_id) assert (bob_messages[0].content == 'Hello Bob') print("All tests succesfull!") network.stop(True) exit()
def main(): backend = EQSNBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) network.delay = 0.0 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} network.start(nodes, backend) network.packet_drop_rate = 0.5 network.delay = 0 hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) # ACKs for 1 hop take at most 2 seconds hosts['alice'].max_ack_wait = 0.5 num_acks = 0 # don't make more then 10 attempts, since of receiver window. num_messages = 20 for _ in range(num_messages): ack = hosts['alice'].send_classical(hosts['bob'].host_id, 'Hello Bob', await_ack=True) if ack: num_acks += 1 num_messages_bob_received = len(hosts['bob'].classical) assert num_acks != num_messages assert num_acks < num_messages assert num_messages_bob_received < num_messages # ACKs can also get dropped assert num_messages_bob_received > num_acks assert float(num_acks) / num_messages < 0.9 print("All tests succesfull!") network.stop(True) exit()
def main(): backend = CQCBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) network.delay = 0.7 hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) q_id = hosts['alice'].send_epr(hosts['bob'].host_id) q1 = hosts['alice'].shares_epr(hosts['bob'].host_id) i = 0 while not q1 and i < MAX_WAIT: q1 = hosts['alice'].shares_epr(hosts['bob'].host_id) i += 1 time.sleep(1) i = 0 q2 = hosts['bob'].shares_epr(hosts['alice'].host_id) while not q2 and i < 5: q2 = hosts['bob'].shares_epr(hosts['alice'].host_id) i += 1 time.sleep(1) assert hosts['alice'].shares_epr(hosts['bob'].host_id) assert hosts['bob'].shares_epr(hosts['alice'].host_id) q_alice = hosts['alice'].get_epr(hosts['bob'].host_id, q_id) q_bob = hosts['bob'].get_epr(hosts['alice'].host_id, q_id) assert q_alice is not None assert q_bob is not None assert q_alice.measure() == q_bob.measure() assert not hosts['alice'].shares_epr(hosts['bob'].host_id) assert not hosts['bob'].shares_epr(hosts['alice'].host_id) print("All tests succesfull!") network.stop(True) exit()
def main(): backend = CQCBackend() network = Network.get_instance() nodes = ["Alice", "Bob", "Eve", "Dean"] network.start(nodes, backend) hosts = {'alice': Host('Alice', backend), 'bob': Host('Bob', backend)} network.delay = 0 # A <-> B hosts['alice'].add_connection('Bob') hosts['bob'].add_connection('Alice') hosts['alice'].storage_epr_limit = 1 hosts['bob'].storage_epr_limit = 1 hosts['alice'].start() hosts['bob'].start() for h in hosts.values(): network.add_host(h) hosts['alice'].max_ack_wait = 10 hosts['alice'].send_epr(hosts['bob'].host_id, await_ack=True) hosts['alice'].send_epr(hosts['bob'].host_id, await_ack=True) assert hosts['alice'].shares_epr(hosts['bob'].host_id) print(hosts['alice'].get_epr_pairs(hosts['bob'].host_id)) assert len(hosts['alice'].get_epr_pairs(hosts['bob'].host_id)) == 1 assert hosts['bob'].shares_epr(hosts['alice'].host_id) assert len(hosts['bob'].get_epr_pairs(hosts['alice'].host_id)) == 1 hosts['alice'].set_epr_memory_limit(2, hosts['bob'].host_id) hosts['bob'].set_epr_memory_limit(2) hosts['alice'].send_epr(hosts['bob'].host_id, await_ack=True) hosts['alice'].send_epr(hosts['bob'].host_id, await_ack=True) assert len(hosts['alice'].get_epr_pairs(hosts['bob'].host_id)) == 2 assert len(hosts['bob'].get_epr_pairs(hosts['alice'].host_id)) == 2 print("All tests succesfull!") network.stop(True) exit()