def test_local_qasm_simulator(self):
        """Test execute.

        If all correct should the data.
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        qr = QP_program.get_quantum_register("qname")
        cr = QP_program.get_classical_register("cname")
        qc2 = QP_program.create_circuit("qc2", [qr], [cr])
        qc3 = QP_program.create_circuit("qc3", [qr], [cr])
        qc2.h(qr[0])
        qc2.cx(qr[0], qr[1])
        qc2.cx(qr[0], qr[2])
        qc3.h(qr)
        qc2.measure(qr[0], cr[0])
        qc3.measure(qr[0], cr[0])
        qc2.measure(qr[1], cr[1])
        qc3.measure(qr[1], cr[1])
        qc2.measure(qr[2], cr[2])
        qc3.measure(qr[2], cr[2])
        circuits = ['qc2', 'qc3']
        shots = 1024  # the number of shots in the experiment.
        backend = 'local_qasm_simulator'
        out = QP_program.execute(circuits, backend=backend, shots=shots,
                                 seed=88)
        results2 = out.get_counts('qc2')
        results3 = out.get_counts('qc3')
        # print(QP_program.get_data('qc3'))
        self.assertEqual(results2, {'000': 518, '111': 506})
        self.assertEqual(results3, {'001': 119, '111': 129, '110': 134,
                                    '100': 117, '000': 129, '101': 126,
                                    '010': 145, '011': 125})

    def test_get_qasm_all_gates(self):
        """Test the get_qasm for more gates.

        If all correct the qasm output should be of a certain lenght

        Previusly:
            Libraries:
                from qiskit import QuantumProgram
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        qc = QP_program.get_circuit("circuitName")
        qr = QP_program.get_quantum_register("qname")
        cr = QP_program.get_classical_register("cname")
        qc.u1(0.3, qr[0])
        qc.u2(0.2, 0.1, qr[1])
        qc.u3(0.3, 0.2, 0.1, qr[2])
        qc.s(qr[1])
        qc.s(qr[2]).inverse()
        qc.cx(qr[1], qr[2])
        qc.barrier()
        qc.cx(qr[0], qr[1])
        qc.h(qr[0])
        qc.x(qr[2]).c_if(cr, 0)
        qc.y(qr[2]).c_if(cr, 1)
        qc.z(qr[2]).c_if(cr, 2)
        qc.barrier(qr)
        qc.measure(qr[0], cr[0])
        qc.measure(qr[1], cr[1])
        qc.measure(qr[2], cr[2])
        result = QP_program.get_qasm('circuitName')
        self.assertEqual(len(result), 535)

    def test_local_qasm_simulator_one_shot(self):
        """Test sinlge shot of local simulator .

        If all correct should the quantum state.
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        qr = QP_program.get_quantum_register("qname")
        cr = QP_program.get_classical_register("cname")
        qc2 = QP_program.create_circuit("qc2", [qr], [cr])
        qc3 = QP_program.create_circuit("qc3", [qr], [cr])
        qc2.h(qr[0])
        qc3.h(qr[0])
        qc3.cx(qr[0], qr[1])
        qc3.cx(qr[0], qr[2])
        circuits = ['qc2', 'qc3']
        backend = 'local_qasm_simulator'  # the backend to run on
        shots = 1  # the number of shots in the experiment.
        result = QP_program.execute(circuits, backend=backend, shots=shots,
                                    seed=9)
        quantum_state = np.array([0.70710678+0.j, 0.70710678+0.j,
                                  0.00000000+0.j, 0.00000000+0.j,
                                  0.00000000+0.j, 0.00000000+0.j,
                                  0.00000000+0.j, 0.00000000+0.j])
        norm = np.dot(np.conj(quantum_state),
                      result.get_data('qc2')['quantum_state'])
        self.assertAlmostEqual(norm, 1)
        quantum_state = np.array([0.70710678+0.j, 0+0.j,
                                  0.00000000+0.j, 0.00000000+0.j,
                                  0.00000000+0.j, 0.00000000+0.j,
                                  0.00000000+0.j, 0.70710678+0.j])
        norm = np.dot(np.conj(quantum_state),
                      result.get_data('qc3')['quantum_state'])
        self.assertAlmostEqual(norm, 1)

    def test_local_unitary_simulator(self):
        """Test unitary simulator.

        If all correct should the h otimes h and cx.
        """
        QP_program = QuantumProgram()
        q = QP_program.create_quantum_register("q", 2, verbose=False)
        c = QP_program.create_classical_register("c", 2, verbose=False)
        qc1 = QP_program.create_circuit("qc1", [q], [c])
        qc2 = QP_program.create_circuit("qc2", [q], [c])
        qc1.h(q)
        qc2.cx(q[0], q[1])
        circuits = ['qc1', 'qc2']
        backend = 'local_unitary_simulator'  # the backend to run on
        result = QP_program.execute(circuits, backend=backend)
        unitary1 = result.get_data('qc1')['unitary']
        unitary2 = result.get_data('qc2')['unitary']
        unitaryreal1 = np.array([[0.5, 0.5, 0.5, 0.5], [0.5, -0.5, 0.5, -0.5],
                                 [0.5, 0.5, -0.5, -0.5],
                                 [0.5, -0.5, -0.5, 0.5]])
        unitaryreal2 = np.array([[1,  0,  0, 0], [0, 0,  0,  1],
                                 [0.,  0, 1, 0], [0,  1,  0,  0]])
        norm1 = np.trace(np.dot(np.transpose(np.conj(unitaryreal1)), unitary1))
        norm2 = np.trace(np.dot(np.transpose(np.conj(unitaryreal2)), unitary2))
        self.assertAlmostEqual(norm1, 4)
        self.assertAlmostEqual(norm2, 4)

    def test_get_qasms(self):
        """Test the get_qasms.

        If all correct the qasm output for each circuit should be of a certain
        lenght

        Previusly:
            Libraries:
                from qiskit import QuantumProgram
        """
        QP_program = QuantumProgram()
        qr = QP_program.create_quantum_register("qr", 3, verbose=False)
        cr = QP_program.create_classical_register("cr", 3, verbose=False)
        qc1 = QP_program.create_circuit("qc1", [qr], [cr])
        qc2 = QP_program.create_circuit("qc2", [qr], [cr])
        qc1.h(qr[0])
        qc1.cx(qr[0], qr[1])
        qc1.cx(qr[1], qr[2])
        qc1.measure(qr[0], cr[0])
        qc1.measure(qr[1], cr[1])
        qc1.measure(qr[2], cr[2])
        qc2.h(qr)
        qc2.measure(qr[0], cr[0])
        qc2.measure(qr[1], cr[1])
        qc2.measure(qr[2], cr[2])
        result = QP_program.get_qasms(["qc1", "qc2"])
        self.assertEqual(len(result[0]), 173)
        self.assertEqual(len(result[1]), 159)

    def test_average_data(self):
        """Test average_data.

        If all correct should the data.
        """
        QP_program = QuantumProgram()
        q = QP_program.create_quantum_register("q", 2, verbose=False)
        c = QP_program.create_classical_register("c", 2, verbose=False)
        qc = QP_program.create_circuit("qc", [q], [c])
        qc.h(q[0])
        qc.cx(q[0], q[1])
        qc.measure(q[0], c[0])
        qc.measure(q[1], c[1])
        circuits = ['qc']
        shots = 10000  # the number of shots in the experiment.
        backend = 'local_qasm_simulator'
        results = QP_program.execute(circuits, backend=backend, shots=shots)
        observable = {"00": 1, "11": 1, "01": -1, "10": -1}
        meanzz = results.average_data("qc", observable)
        observable = {"00": 1, "11": -1, "01": 1, "10": -1}
        meanzi = results.average_data("qc", observable)
        observable = {"00": 1, "11": -1, "01": -1, "10": 1}
        meaniz = results.average_data("qc", observable)
        self.assertAlmostEqual(meanzz,  1, places=1)
        self.assertAlmostEqual(meanzi,  0, places=1)
        self.assertAlmostEqual(meaniz,  0, places=1)

 def test_get_qasm_all_gates(self):
     """Test the get_qasm for more gates, using an specification without names.
     """
     q_program = QuantumProgram(specs=self.QPS_SPECS_NONAMES)
     qc = q_program.get_circuit()
     qr = q_program.get_quantum_register()
     cr = q_program.get_classical_register()
     qc.u1(0.3, qr[0])
     qc.u2(0.2, 0.1, qr[1])
     qc.u3(0.3, 0.2, 0.1, qr[2])
     qc.s(qr[1])
     qc.s(qr[2]).inverse()
     qc.cx(qr[1], qr[2])
     qc.barrier()
     qc.cx(qr[0], qr[1])
     qc.h(qr[0])
     qc.x(qr[2]).c_if(cr, 0)
     qc.y(qr[2]).c_if(cr, 1)
     qc.z(qr[2]).c_if(cr, 2)
     qc.barrier(qr)
     qc.measure(qr[0], cr[0])
     qc.measure(qr[1], cr[1])
     qc.measure(qr[2], cr[2])
     result = q_program.get_qasm()
     self.assertEqual(len(result), (len(qr.name) * 23 +
                                    len(cr.name) * 7 +
                                    385))

 def test_create_circuit_noname(self):
     """Test create_circuit with no name
     """
     q_program = QuantumProgram()
     qr = q_program.create_quantum_register(size=3)
     cr = q_program.create_classical_register(size=3)
     qc = q_program.create_circuit(qregisters=[qr], cregisters=[cr])
     self.assertIsInstance(qc, QuantumCircuit)

    def test_backend_status(self):
        """Test backend_status.

        If all correct should return dictionary with available: True/False.
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        out = QP_program.get_backend_status("local_qasm_simulator")
        self.assertIn(out['available'], [True])

    def test_local_backends_exist(self):
        """Test if there are local backends.

        If all correct some should exists (even if ofline).
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        QP_program.set_api(API_TOKEN, URL)
        local_backends = QP_program.local_backends()
        self.assertTrue(local_backends)

    def test_setup_api(self):
        """Check the api is set up.

        If all correct is should be true.
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        QP_program.set_api(API_TOKEN, URL)
        config = QP_program.get_api_config()
        self.assertTrue(config)

    def test_get_backend_configuration(self):
        """Test get_backend_configuration.

        If all correct should return configuration for the
        local_qasm_simulator.
        """
        qp = QuantumProgram(specs=QPS_SPECS)
        test = len(qp.get_backend_configuration("local_qasm_simulator"))
        self.assertEqual(test, 6)

    def _get_quantum_program():
        quantum_program = QuantumProgram()
        qr = quantum_program.create_quantum_register("q", 1)
        cr = quantum_program.create_classical_register("c", 1)
        qc = quantum_program.create_circuit("qc", [qr], [cr])
        qc.h(qr[0])
        qc.measure(qr[0], cr[0])

        return quantum_program

 def test_create_classical_registers_noname(self):
     """Test create_classical_registers with no name
     """
     q_program = QuantumProgram()
     classical_registers = [{"size": 4},
                            {"size": 2}]
     crs = q_program.create_classical_registers(classical_registers)
     for i in crs:
         self.assertIsInstance(i, ClassicalRegister)

 def test_create_quantum_registers_noname(self):
     """Test create_quantum_registers with no name.
     """
     q_program = QuantumProgram()
     quantum_registers = [{"size": 4},
                          {"size": 2}]
     qrs = q_program.create_quantum_registers(quantum_registers)
     for i in qrs:
         self.assertIsInstance(i, QuantumRegister)

    def test_json_output(self):
        qp = QuantumProgram()
        qp.load_qasm_file(self.QASM_FILE_PATH, name="example")

        basis_gates = []  # unroll to base gates, change to test
        unroller = unroll.Unroller(qasm.Qasm(data=qp.get_qasm("example")).parse(),
                                   unroll.JsonBackend(basis_gates))
        circuit = unroller.execute()
        self.log.info('test_json_ouptut: %s', circuit)

    def test_load(self):
        """
        Load a Json Quantum Program
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)

        result = QP_program.load("./test/python/test_load.json")
        self.assertEqual(result['status'], 'Done')

        check_result = QP_program.get_qasm('circuitName')
        self.assertEqual(len(check_result), 1872)

    def test_get_initial_circuit(self):
        """Test get_initial_circuit.
        If all correct is should be of the circuit form.

        Previusly:
            Libraries:
                from qiskit import QuantumProgram
        """
        QP_program = QuantumProgram(specs=QPS_SPECS)
        qc = QP_program.get_initial_circuit()
        self.assertIsInstance(qc, QuantumCircuit)

    def test_online_simulators(self):
        """Test if there are online backends (which are simulators).

        If all correct some should exists. NEED internet connection for this.
        """
        # TODO: Jay should we check if we the QX is online before runing.
        qp = QuantumProgram(specs=QPS_SPECS)
        qp.set_api(API_TOKEN, URL)
        online_simulators = qp.online_simulators()
        # print(online_simulators)
        self.assertTrue(isinstance(online_simulators, list))

    def test_online_backends_exist(self):
        """Test if there are online backends.

        If all correct some should exists.
        """
        # TODO: Jay should we check if we the QX is online before runing.
        QP_program = QuantumProgram(specs=QPS_SPECS)
        QP_program.set_api(API_TOKEN, URL)
        online_backends = QP_program.online_backends()
        # print(online_backends)
        self.assertTrue(online_backends)