def test_retrieve_job_uses_appropriate_backend(self, qe_token, qe_url):
"""Test that retrieved jobs come from their appropriate backend."""
IBMQ.enable_account(qe_token, qe_url)
simulator_backend = IBMQ.get_backend('ibmq_qasm_simulator')
backends = IBMQ.backends(simulator=False)
real_backend = least_busy(backends)
qobj_sim = compile(self._qc, simulator_backend)
job_sim = simulator_backend.run(qobj_sim)
qobj_real = compile(self._qc, real_backend)
job_real = real_backend.run(qobj_real)
# test a retrieved job's backend is the same as the queried backend
self.assertEqual(simulator_backend.retrieve_job(job_sim.job_id()).backend().name(),
simulator_backend.name())
self.assertEqual(real_backend.retrieve_job(job_real.job_id()).backend().name(),
real_backend.name())
# test retrieve requests for jobs that exist on other backends throw errors
with self.assertWarns(Warning) as context_manager:
self.assertRaises(IBMQBackendError,
simulator_backend.retrieve_job, job_real.job_id())
self.assertIn('belongs to', str(context_manager.warning))
with self.assertWarns(Warning) as context_manager:
self.assertRaises(IBMQBackendError,
real_backend.retrieve_job, job_sim.job_id())
self.assertIn('belongs to', str(context_manager.warning))
def test_multi_register_reordering(self, qe_token, qe_url):
"""a more complicated reordering across 3 registers of different sizes"""
sim, real = self._get_backends(qe_token, qe_url)
if not sim or not real:
raise unittest.SkipTest('no remote device available')
qr0 = QuantumRegister(2)
qr1 = QuantumRegister(2)
qr2 = QuantumRegister(1)
cr0 = ClassicalRegister(2)
cr1 = ClassicalRegister(2)
cr2 = ClassicalRegister(1)
circuit = QuantumCircuit(qr0, qr1, qr2, cr0, cr1, cr2)
circuit.h(qr0[0])
circuit.cx(qr0[0], qr2[0])
circuit.x(qr1[1])
circuit.h(qr2[0])
circuit.cx(qr2[0], qr1[0])
circuit.barrier()
circuit.measure(qr0[0], cr2[0])
circuit.measure(qr0[1], cr0[1])
circuit.measure(qr1[0], cr0[0])
circuit.measure(qr1[1], cr1[0])
circuit.measure(qr2[0], cr1[1])
shots = 4000
qobj_real = compile(circuit, real)
qobj_sim = compile(circuit, sim)
result_real = real.run(qobj_real).result(timeout=600)
result_sim = sim.run(qobj_sim).result(timeout=600)
counts_real = result_real.get_counts()
counts_sim = result_sim.get_counts()
threshold = 0.2 * shots
self.assertDictAlmostEqual(counts_real, counts_sim, threshold)
def test_run_simulator(self, qe_token, qe_url):
"""Test running in a simulator."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qr = QuantumRegister(2, 'q')
cr = ClassicalRegister(2, 'c')
qc = QuantumCircuit(qr, cr, name='hadamard')
qc.h(qr)
qc.measure(qr, cr)
qobj = compile([self._qc, qc], backend)
shots = qobj.config.shots
job = backend.run(qobj)
result = job.result()
counts_qx1 = result.get_counts(0)
counts_qx2 = result.get_counts(1)
counts_ex1 = {'00': shots/2, '11': shots/2}
counts_ex2 = {'00': shots/4, '11': shots/4, '10': shots/4, '01': shots/4}
states1 = counts_qx1.keys() | counts_ex1.keys()
states2 = counts_qx2.keys() | counts_ex2.keys()
# contingency table
ctable1 = numpy.array([[counts_qx1.get(key, 0) for key in states1],
[counts_ex1.get(key, 0) for key in states1]])
ctable2 = numpy.array([[counts_qx2.get(key, 0) for key in states2],
[counts_ex2.get(key, 0) for key in states2]])
self.log.info('states1: %s', str(states1))
self.log.info('states2: %s', str(states2))
self.log.info('ctable1: %s', str(ctable1))
self.log.info('ctable2: %s', str(ctable2))
contingency1 = chi2_contingency(ctable1)
contingency2 = chi2_contingency(ctable2)
self.log.info('chi2_contingency1: %s', str(contingency1))
self.log.info('chi2_contingency2: %s', str(contingency2))
self.assertGreater(contingency1[1], 0.01)
self.assertGreater(contingency2[1], 0.01)
def test_multi_register(self):
"""Test one circuit, two registers, out-of-order readout."""
qr1 = QuantumRegister(2)
qr2 = QuantumRegister(2)
cr1 = ClassicalRegister(3)
cr2 = ClassicalRegister(1)
circuit = QuantumCircuit(qr1, qr2, cr1, cr2)
circuit.h(qr1[0])
circuit.cx(qr1[0], qr2[1])
circuit.h(qr2[0])
circuit.cx(qr2[0], qr1[1])
circuit.x(qr1[1])
circuit.measure(qr1[0], cr2[0])
circuit.measure(qr1[1], cr1[0])
circuit.measure(qr1[1], cr2[0])
circuit.measure(qr1[1], cr1[2])
circuit.measure(qr2[0], cr1[2])
circuit.measure(qr2[1], cr1[1])
qobj = compile(circuit, self._remote_backend)
result_remote = self._remote_backend.run(qobj).result()
result_local = self._local_backend.run(qobj).result()
self.assertDictAlmostEqual(result_remote.get_counts(circuit),
result_local.get_counts(circuit),
delta=50)
def test_run_circuit(self):
"""Test running a single circuit."""
qobj = compile(self.circuit, self.backend)
job = self.backend.run(qobj)
result = job.result()
self.assertEqual(result.success, True)
return result
def test_execute_several_circuits_simulator_online(self, qe_token, qe_url):
"""Test execute_several_circuits_simulator_online."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qcr1 = QuantumCircuit(qr, cr, name='qc1')
qcr2 = QuantumCircuit(qr, cr, name='qc2')
qcr1.h(qr)
qcr2.h(qr[0])
qcr2.cx(qr[0], qr[1])
qcr1.measure(qr[0], cr[0])
qcr1.measure(qr[1], cr[1])
qcr2.measure(qr[0], cr[0])
qcr2.measure(qr[1], cr[1])
shots = 1024
qobj = compile([qcr1, qcr2],
backend=backend,
seed=73846087,
shots=shots)
job = backend.run(qobj)
result = job.result()
counts1 = result.get_counts(qcr1)
counts2 = result.get_counts(qcr2)
target1 = {
'00': shots / 4,
'01': shots / 4,
'10': shots / 4,
'11': shots / 4
}
target2 = {'00': shots / 2, '11': shots / 2}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts1, target1, threshold)
self.assertDictAlmostEqual(counts2, target2, threshold)
def test_run_device(self, qe_token, qe_url):
"""Test running in a real device."""
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends(simulator=False)
self.log.info('devices: %s', [b.name() for b in backends])
backend = least_busy(backends)
self.log.info('using backend: %s', backend.name())
qobj = compile(self._qc, backend)
shots = qobj.config.shots
job = backend.run(qobj)
while not job.status() is JobStatus.DONE:
self.log.info(job.status())
time.sleep(4)
self.log.info(job.status)
result = job.result()
counts_qx = result.get_counts(0)
counts_ex = {'00': shots / 2, '11': shots / 2}
states = counts_qx.keys() | counts_ex.keys()
# contingency table
ctable = numpy.array([[counts_qx.get(key, 0) for key in states],
[counts_ex.get(key, 0) for key in states]])
self.log.info('states: %s', str(states))
self.log.info('ctable: %s', str(ctable))
contingency = chi2_contingency(ctable)
self.log.info('chi2_contingency: %s', str(contingency))
self.assertDictAlmostEqual(counts_qx, counts_ex, shots * 0.1)
def test_online_qasm_simulator_two_registers(self, qe_token, qe_url):
"""Test online_qasm_simulator_two_registers."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qr1 = QuantumRegister(2)
cr1 = ClassicalRegister(2)
qr2 = QuantumRegister(2)
cr2 = ClassicalRegister(2)
qcr1 = QuantumCircuit(qr1, qr2, cr1, cr2, name="circuit1")
qcr2 = QuantumCircuit(qr1, qr2, cr1, cr2, name="circuit2")
qcr1.x(qr1[0])
qcr2.x(qr2[1])
qcr1.measure(qr1[0], cr1[0])
qcr1.measure(qr1[1], cr1[1])
qcr1.measure(qr2[0], cr2[0])
qcr1.measure(qr2[1], cr2[1])
qcr2.measure(qr1[0], cr1[0])
qcr2.measure(qr1[1], cr1[1])
qcr2.measure(qr2[0], cr2[0])
qcr2.measure(qr2[1], cr2[1])
shots = 1024
qobj = compile([qcr1, qcr2],
backend,
seed=8458,
shots=shots,
seed_mapper=88434)
job = backend.run(qobj)
result = job.result()
result1 = result.get_counts(qcr1)
result2 = result.get_counts(qcr2)
self.assertEqual(result1, {'00 01': 1024})
self.assertEqual(result2, {'10 00': 1024})
def test_get_backend_name(self, qe_token, qe_url):
"""Test getting a backend name."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
job = backend.run(qobj)
self.assertTrue(job.backend().name() == backend.name())
def test_qobj_enabled_result(self):
"""Jobs can be retrieved."""
qobj = compile(self._qc, self._backend)
job = self._backend.run(qobj)
try:
job.result()
except JobError as err:
self.fail(err)
def test_job_id(self, qe_token, qe_url):
"""Test getting a job id."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
job = backend.run(qobj)
self.log.info('job_id: %s', job.job_id())
self.assertTrue(job.job_id() is not None)
def test_double_submit_fails(self, qe_token, qe_url):
"""Test submitting a job twice."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
# backend.run() will automatically call job.submit()
job = backend.run(qobj)
with self.assertRaises(JobError):
job.submit()
def test_api_run_job_fail_backend(self, qe_token, qe_url):
"""Test running a job against an invalid backend."""
IBMQ.enable_account(qe_token, qe_url)
backend_name = 'ibmq_qasm_simulator'
backend = IBMQ.get_backend(backend_name)
qobj = compile(self.qc1, backend=backend, seed=self.seed, shots=1)
api = backend._api
self.assertRaises(BadBackendError, api.run_job, qobj.as_dict(),
'INVALID_BACKEND_NAME')
def test_readout_order(self):
"""Test one circuit, one register, out-of-order readout.
"""
qr = QuantumRegister(4)
cr = ClassicalRegister(4)
circuit = QuantumCircuit(qr, cr)
circuit.x(qr[0])
circuit.x(qr[2])
circuit.measure(qr[0], cr[2])
circuit.measure(qr[1], cr[0])
circuit.measure(qr[2], cr[1])
circuit.measure(qr[3], cr[3])
qobj_remote = compile(circuit, self._remote_backend)
qobj_local = compile(circuit, self._local_backend)
result_remote = self._remote_backend.run(qobj_remote).result()
result_local = self._local_backend.run(qobj_local).result()
self.assertDictAlmostEqual(result_remote.get_counts(circuit),
result_local.get_counts(circuit),
delta=50)
def test_retrieve_job(self, qe_token, qe_url):
"""Test retrieving a single job."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
job = backend.run(qobj)
rjob = backend.retrieve_job(job.job_id())
self.assertEqual(job.job_id(), rjob.job_id())
self.assertEqual(job.result().get_counts(), rjob.result().get_counts())
self.assertEqual(job.qobj().as_dict(), qobj.as_dict())
def test_run_async_simulator(self, qe_token, qe_url):
"""Test running in a simulator asynchronously."""
IBMQJob._executor = futures.ThreadPoolExecutor(max_workers=2)
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
self.log.info('submitting to backend %s', backend.name())
num_qubits = 16
qr = QuantumRegister(num_qubits, 'qr')
cr = ClassicalRegister(num_qubits, 'cr')
qc = QuantumCircuit(qr, cr)
for i in range(num_qubits - 1):
qc.cx(qr[i], qr[i + 1])
qc.measure(qr, cr)
qobj = compile([qc] * 10, backend)
num_jobs = 5
job_array = [backend.run(qobj) for _ in range(num_jobs)]
found_async_jobs = False
timeout = 30
start_time = time.time()
while not found_async_jobs:
check = sum(
[job.status() is JobStatus.RUNNING for job in job_array])
if check >= 2:
self.log.info('found %d simultaneous jobs', check)
break
if all([job.status() is JobStatus.DONE for job in job_array]):
# done too soon? don't generate error
self.log.warning('all jobs completed before simultaneous jobs '
'could be detected')
break
for job in job_array:
self.log.info('%s %s %s %s', job.status(),
job.status() is JobStatus.RUNNING, check,
job.job_id())
self.log.info('- %s', str(time.time() - start_time))
if time.time() - start_time > timeout:
raise TimeoutError('failed to see multiple running jobs after '
'{0} s'.format(timeout))
time.sleep(0.2)
result_array = [job.result() for job in job_array]
self.log.info('got back all job results')
# Ensure all jobs have finished.
self.assertTrue(
all([job.status() is JobStatus.DONE for job in job_array]))
self.assertTrue(all([result.success for result in result_array]))
# Ensure job ids are unique.
job_ids = [job.job_id() for job in job_array]
self.assertEqual(sorted(job_ids), sorted(list(set(job_ids))))
def test_cancel(self, qe_token, qe_url):
"""Test job cancelation."""
IBMQ.enable_account(qe_token, qe_url)
backend_name = ('ibmq_20_tokyo'
if self.using_ibmq_credentials else 'ibmqx4')
backend = IBMQ.get_backend(backend_name)
qobj = compile(self._qc, backend)
job = backend.run(qobj)
self.wait_for_initialization(job, timeout=5)
can_cancel = job.cancel()
self.assertTrue(can_cancel)
self.assertTrue(job.status() is JobStatus.CANCELLED)
def test_one_qubit_no_operation(self):
"""Test one circuit, one register, in-order readout."""
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.measure(qr[0], cr[0])
qobj = compile(circuit, self._remote_backend)
result_remote = self._remote_backend.run(qobj).result()
result_local = self._local_backend.run(qobj).result()
self.assertDictAlmostEqual(result_remote.get_counts(circuit),
result_local.get_counts(circuit),
delta=50)
def test_api_run_job(self, qe_token, qe_url):
"""Test running a job against a simulator."""
IBMQ.enable_account(qe_token, qe_url)
backend_name = 'ibmq_qasm_simulator'
backend = IBMQ.get_backend(backend_name)
qobj = compile(self.qc1, backend=backend, seed=self.seed, shots=1)
api = backend._api
job = api.run_job(qobj.as_dict(), backend_name)
check_status = None
if 'status' in job:
check_status = job['status']
self.assertIsNotNone(check_status)
def test_basic_reordering(self, qe_token, qe_url):
"""a simple reordering within a 2-qubit register"""
sim, real = self._get_backends(qe_token, qe_url)
if not sim or not real:
raise unittest.SkipTest('no remote device available')
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.measure(qr[0], cr[1])
circuit.measure(qr[1], cr[0])
shots = 2000
qobj_real = compile(circuit, real)
qobj_sim = compile(circuit, sim)
result_real = real.run(qobj_real).result(timeout=600)
result_sim = sim.run(qobj_sim).result(timeout=600)
counts_real = result_real.get_counts()
counts_sim = result_sim.get_counts()
self.log.info(counts_real)
self.log.info(counts_sim)
threshold = 0.1 * shots
self.assertDictAlmostEqual(counts_real, counts_sim, threshold)
def test_atlantic_circuit(self):
"""Test Atlantis deterministic ry operation."""
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
circuit = QuantumCircuit(qr, cr)
circuit.ry(pi, qr[0])
circuit.ry(pi, qr[2])
circuit.measure(qr, cr)
qobj = compile(circuit, self._remote_backend)
result_remote = self._remote_backend.run(qobj).result()
result_local = self._local_backend.run(qobj).result()
self.assertDictAlmostEqual(result_remote.get_counts(circuit),
result_local.get_counts(circuit),
delta=50)
def test_compile_run_remote(self, qe_token, qe_url):
"""Test Compiler and run remote."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend(local=False, simulator=True)
qubit_reg = QuantumRegister(2, name='q')
clbit_reg = ClassicalRegister(2, name='c')
qc = QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc.h(qubit_reg[0])
qc.cx(qubit_reg[0], qubit_reg[1])
qc.measure(qubit_reg, clbit_reg)
qobj = compile(qc, backend, seed=self.seed)
job = backend.run(qobj)
result = job.result(timeout=20)
self.assertIsInstance(result, Result)
def test_retrieve_job(self, qe_token, qe_url):
"""Test retrieving a single job."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qobj = compile(self._qc, backend)
job = backend.run(qobj)
rjob = backend.retrieve_job(job.job_id())
self.assertEqual(job.job_id(), rjob.job_id())
self.assertEqual(job.result().get_counts(), rjob.result().get_counts())
if getattr(backend.configuration(), 'allow_q_object'):
self.assertEqual(job.qobj().as_dict(), qobj.as_dict())
else:
self.assertEqual(job.qobj(), None)
def test_run_async_device(self, qe_token, qe_url):
"""Test running in a real device asynchronously."""
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends(simulator=False)
backend = least_busy(backends)
self.log.info('submitting to backend %s', backend.name())
num_qubits = 5
qr = QuantumRegister(num_qubits, 'qr')
cr = ClassicalRegister(num_qubits, 'cr')
qc = QuantumCircuit(qr, cr)
for i in range(num_qubits - 1):
qc.cx(qr[i], qr[i + 1])
qc.measure(qr, cr)
qobj = compile(qc, backend)
num_jobs = 3
job_array = [backend.run(qobj) for _ in range(num_jobs)]
time.sleep(3) # give time for jobs to start (better way?)
job_status = [job.status() for job in job_array]
num_init = sum(
[status is JobStatus.INITIALIZING for status in job_status])
num_queued = sum([status is JobStatus.QUEUED for status in job_status])
num_running = sum(
[status is JobStatus.RUNNING for status in job_status])
num_done = sum([status is JobStatus.DONE for status in job_status])
num_error = sum([status is JobStatus.ERROR for status in job_status])
self.log.info('number of currently initializing jobs: %d/%d', num_init,
num_jobs)
self.log.info('number of currently queued jobs: %d/%d', num_queued,
num_jobs)
self.log.info('number of currently running jobs: %d/%d', num_running,
num_jobs)
self.log.info('number of currently done jobs: %d/%d', num_done,
num_jobs)
self.log.info('number of errored jobs: %d/%d', num_error, num_jobs)
self.assertTrue(num_jobs - num_error - num_done > 0)
# Wait for all the results.
result_array = [job.result() for job in job_array]
# Ensure all jobs have finished.
self.assertTrue(
all([job.status() is JobStatus.DONE for job in job_array]))
self.assertTrue(all([result.success for result in result_array]))
# Ensure job ids are unique.
job_ids = [job.job_id() for job in job_array]
self.assertEqual(sorted(job_ids), sorted(list(set(job_ids))))
def test_run_job(self, qe_token, qe_url):
"""Test running a job against a simulator."""
_ = self._get_client(qe_token, qe_url)
IBMQ.enable_account(qe_token, qe_url)
# Create a Qobj.
backend_name = 'ibmq_qasm_simulator'
backend = IBMQ.get_backend(backend_name)
qobj = compile(self.qc1, backend=backend, seed=self.seed, shots=1)
# Run the job through the IBMQClient directly.
api = backend._api
job = api.run_job(qobj.as_dict(), backend_name)
self.assertIn('status', job)
self.assertIsNotNone(job['status'])
def test_conditional_operation(self):
"""Test conditional operation."""
qr = QuantumRegister(4)
cr = ClassicalRegister(4)
circuit = QuantumCircuit(qr, cr)
circuit.x(qr[0])
circuit.x(qr[2])
circuit.measure(qr[0], cr[0])
circuit.x(qr[0]).c_if(cr, 1)
qobj = compile(circuit, self._remote_backend)
result_remote = self._remote_backend.run(qobj).result()
result_local = self._local_backend.run(qobj).result()
self.assertDictAlmostEqual(result_remote.get_counts(circuit),
result_local.get_counts(circuit),
delta=50)
def test_execute_one_circuit_simulator_online(self, qe_token, qe_url):
"""Test execute_one_circuit_simulator_online."""
IBMQ.enable_account(qe_token, qe_url)
backend = IBMQ.get_backend('ibmq_qasm_simulator')
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr, name='qc')
qc.h(qr[0])
qc.measure(qr[0], cr[0])
qobj = compile(qc, backend=backend, seed=73846087)
shots = qobj.config.shots
job = backend.run(qobj)
result = job.result()
counts = result.get_counts(qc)
target = {'0': shots / 2, '1': shots / 2}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts, target, threshold)
def test_get_job_includes(self, qe_token, qe_url):
"""Check the field includes parameter for get_job."""
_ = self._get_api(qe_token, qe_url)
IBMQ.enable_account(qe_token, qe_url)
backend_name = 'ibmq_qasm_simulator'
backend = IBMQ.get_backend(backend_name)
qobj = compile([self.qc1, self.qc2],
backend=backend, seed=self.seed, shots=1)
api = backend._api
job = api.run_job(qobj.as_dict(), backend_name)
job_id = job['id']
# Get the job, excluding a parameter.
self.assertIn('deleted', job)
job_excluded = api.get_job(job_id, exclude_fields=['deleted'])
self.assertNotIn('deleted', job_excluded)
def test_run_device(self, qe_token, qe_url):
"""Test running in a real device."""
IBMQ.enable_account(qe_token, qe_url)
backend = least_busy(IBMQ.backends(simulator=False))
qobj = compile(self._qc, backend)
shots = qobj.config.shots
job = backend.run(qobj)
while not job.status() is JobStatus.DONE:
time.sleep(4)
result = job.result()
counts_qx = result.get_counts(0)
counts_ex = {'00': shots/2, '11': shots/2}
self.assertDictAlmostEqual(counts_qx, counts_ex, shots*0.1)
# Test fetching the job properties, as this is a real backend and is
# guaranteed to have them.
_ = job.properties()
def test_qobj_headers_in_result_devices(self, qe_token, qe_url):
"""Test that the qobj headers are passed onto the results for devices."""
IBMQ.enable_account(qe_token, qe_url)
backends = IBMQ.backends(simulator=False)
custom_qobj_header = {'x': 1, 'y': [1, 2, 3], 'z': {'a': 4}}
for backend in backends:
with self.subTest(backend=backend):
qobj = compile(self.qc1, backend)
# Update the Qobj header.
qobj.header = QobjHeader.from_dict(custom_qobj_header)
# Update the Qobj.experiment header.
qobj.experiments[0].header.some_field = 'extra info'
result = backend.run(qobj).result()
self.assertEqual(result.header.to_dict(), custom_qobj_header)
self.assertEqual(result.results[0].header.some_field,
'extra info')
