From 3be642a1593d3d92f2ea861d136631706f60226b Mon Sep 17 00:00:00 2001 From: David Straub Date: Wed, 8 Nov 2017 18:04:10 +0100 Subject: [PATCH] Update docs --- docs/ckmutil/diag.m.html | 1178 ++++++++++ docs/ckmutil/index.html | 37 +- docs/ckmutil/phases.m.html | 1294 +++++++++++ docs/ckmutil/test_ckm.m.html | 15 + docs/ckmutil/test_phases.m.html | 3662 +++++++++++++++++++++++++++++++ 5 files changed, 6183 insertions(+), 3 deletions(-) create mode 100644 docs/ckmutil/diag.m.html create mode 100644 docs/ckmutil/phases.m.html create mode 100644 docs/ckmutil/test_phases.m.html diff --git a/docs/ckmutil/diag.m.html b/docs/ckmutil/diag.m.html new file mode 100644 index 0000000..861f60f --- /dev/null +++ b/docs/ckmutil/diag.m.html @@ -0,0 +1,1178 @@ + + + + + + ckmutil.diag API documentation + + + + + + + + + + + + + + + + + + + +Top + +
+ + + + +
+ + + + + + +
+

ckmutil.diag module

+

Functions for the diagonalization of fermion mass matrices.

+ +

Show source ≡

+
+ 
"""Functions for the diagonalization of fermion mass matrices."""
+
+import numpy as np
+
+def msvd(m):
+  """Modified singular value decomposition.
+
+  Returns U, S, V where Udagger M V = diag(S) and the singular values
+  are sorted in ascending order (small to large).
+  """
+  u, s, vdgr = np.linalg.svd(m)
+  order = s.argsort()
+  # reverse the n first columns of u
+  s = s[order]
+  u= u[:,order]
+  vdgr = vdgr[order]
+  return u, s, vdgr.conj().T
+
+ +
+ +
+ +
+ +

Functions

+ +
+
+

def msvd(

m)

+
+ + + + +

Modified singular value decomposition.

+

Returns U, S, V where Udagger M V = diag(S) and the singular values +are sorted in ascending order (small to large).

+
+

Show source ≡

+
+ 
def msvd(m):
+  """Modified singular value decomposition.
+
+  Returns U, S, V where Udagger M V = diag(S) and the singular values
+  are sorted in ascending order (small to large).
+  """
+  u, s, vdgr = np.linalg.svd(m)
+  order = s.argsort()
+  # reverse the n first columns of u
+  s = s[order]
+  u= u[:,order]
+  vdgr = vdgr[order]
+  return u, s, vdgr.conj().T
+
+ +
+
+ +
+ + + +
+ +
+
+ +
+ + + + + + diff --git a/docs/ckmutil/index.html b/docs/ckmutil/index.html index d3a6a00..637cb6f 100644 --- a/docs/ckmutil/index.html +++ b/docs/ckmutil/index.html @@ -4,7 +4,8 @@ ckmutil API documentation - + @@ -1056,7 +1057,10 @@

Index

  • Sub-modules

    • @@ -1071,11 +1075,17 @@

    Index

    ckmutil module

    - +

    Package containing useful functions to deal with the +Cabibbo-Kobayashi-Maskawa (CKM) quark mixing matrix or +the Pontecorvo-Maki-Nakagawa-Sakata (PMNS) lepton mixing matrix +in high energy physics.

    Show source ≡

    - 
    from . import ckm
+    
    """Package containing useful functions to deal with the
+Cabibbo-Kobayashi-Maskawa (CKM) quark mixing matrix or
+the Pontecorvo-Maki-Nakagawa-Sakata (PMNS) lepton mixing matrix
+in high energy physics."""
    @@ -1094,12 +1104,33 @@

    Sub-modules

    Functions needed for the CKM matrix as well as for frequently used combinations of CKM elements.

    +
    +
    +

    ckmutil.diag

    + + +

    Functions for the diagonalization of fermion mass matrices.

    + +
    +
    +

    ckmutil.phases

    + + +

    Functions for the extraction of mixing angles and phases and for rephasing +general mixing matrices to standard parametrizations.

    +

    ckmutil.test_ckm

    +
    +
    +

    ckmutil.test_phases

    + + +
    diff --git a/docs/ckmutil/phases.m.html b/docs/ckmutil/phases.m.html new file mode 100644 index 0000000..d645385 --- /dev/null +++ b/docs/ckmutil/phases.m.html @@ -0,0 +1,1294 @@ + + + + + + ckmutil.phases API documentation + + + + + + + + + + + + + + + + + + + +Top + +
    + + + + +
    + + + + + + +
    +

    ckmutil.phases module

    +

    Functions for the extraction of mixing angles and phases and for rephasing +general mixing matrices to standard parametrizations.

    + +

    Show source ≡

    +
    + 
    """Functions for the extraction of mixing angles and phases and for rephasing
+general mixing matrices to standard parametrizations."""
+
+import numpy as np
+from math import asin, atan, sin, cos
+from cmath import phase, exp
+
+def mixing_phases(U):
+    """Return the angles and CP phases of the CKM or PMNS matrix
+    in standard parametrization, starting from a matrix with arbitrary phase
+    convention."""
+    f = {}
+    # angles
+    f['t13'] = asin(abs(U[0,2]))
+    if U[0,0] == 0:
+        f['t12'] = pi/2
+    else:
+        f['t12'] = atan(abs(U[0,1])/abs(U[0,0]))
+    if U[2,2] == 0:
+        f['t23'] = pi/2
+    else:
+        f['t23'] = atan(abs(U[1,2])/abs(U[2,2]))
+    s12 = sin(f['t12'])
+    c12 = cos(f['t12'])
+    s13 = sin(f['t13'])
+    c13 = cos(f['t13'])
+    s23 = sin(f['t23'])
+    c23 = cos(f['t23'])
+    # standard phase
+    if (s12*s23) == 0 or (c12*c13**2*c23*s13) == 0:
+        f['delta'] = 0
+    else:
+        f['delta'] = -phase((U[0,0].conj()*U[0,2]*U[2,0]*U[2,2].conj()/(c12*c13**2*c23*s13) + c12*c23*s13)/(s12*s23))
+    # Majorana phases
+    f['delta1']  = phase(exp(1j*f['delta']) * U[0, 2])
+    f['delta2']  = phase(U[1, 2])
+    f['delta3']  = phase(U[2, 2])
+    f['phi1'] = 2*phase(exp(1j*f['delta1']) * U[0, 0].conj())
+    f['phi2'] = 2*phase(exp(1j*f['delta1']) * U[0, 1].conj())
+    return f
+
+def rephase_standard(UuL, UdL, UuR, UdR):
+    """Function to rephase the quark rotation matrices in order to
+    obtain the CKM matrix in standard parametrization.
+
+    The input matrices are assumed to diagonalize the up-type and down-type
+    quark matrices like
+
+    ```
+    UuL.conj().T @ Mu @ UuR = Mu_diag
+    UdL.conj().T @ Md @ UdR = Md_diag
+    ```
+
+    The CKM matrix is given as `VCKM = UuL.conj().T @ UdL`.
+
+    Returns a tuple with the rephased versions of the input matrices.
+    """
+    K = UuL.conj().T @ UdL
+    f = mixing_phases(K)
+    Fdelta = np.diag(np.exp([1j*f['delta1'], 1j*f['delta2'], 1j*f['delta3']]))
+    Fphi = np.diag(np.exp([-1j*f['phi1']/2., -1j*f['phi2']/2., 0]))
+    return UuL @ Fdelta, UdL @ Fphi.conj(), UuR @ Fdelta, UdR @ Fphi.conj()
+
    + +
    + +
    + +
    + +

    Functions

    + +
    +
    +

    def mixing_phases(

    U)

    +
    + + + + +

    Return the angles and CP phases of the CKM or PMNS matrix +in standard parametrization, starting from a matrix with arbitrary phase +convention.

    +
    +

    Show source ≡

    +
    + 
    def mixing_phases(U):
+    """Return the angles and CP phases of the CKM or PMNS matrix
+    in standard parametrization, starting from a matrix with arbitrary phase
+    convention."""
+    f = {}
+    # angles
+    f['t13'] = asin(abs(U[0,2]))
+    if U[0,0] == 0:
+        f['t12'] = pi/2
+    else:
+        f['t12'] = atan(abs(U[0,1])/abs(U[0,0]))
+    if U[2,2] == 0:
+        f['t23'] = pi/2
+    else:
+        f['t23'] = atan(abs(U[1,2])/abs(U[2,2]))
+    s12 = sin(f['t12'])
+    c12 = cos(f['t12'])
+    s13 = sin(f['t13'])
+    c13 = cos(f['t13'])
+    s23 = sin(f['t23'])
+    c23 = cos(f['t23'])
+    # standard phase
+    if (s12*s23) == 0 or (c12*c13**2*c23*s13) == 0:
+        f['delta'] = 0
+    else:
+        f['delta'] = -phase((U[0,0].conj()*U[0,2]*U[2,0]*U[2,2].conj()/(c12*c13**2*c23*s13) + c12*c23*s13)/(s12*s23))
+    # Majorana phases
+    f['delta1']  = phase(exp(1j*f['delta']) * U[0, 2])
+    f['delta2']  = phase(U[1, 2])
+    f['delta3']  = phase(U[2, 2])
+    f['phi1'] = 2*phase(exp(1j*f['delta1']) * U[0, 0].conj())
+    f['phi2'] = 2*phase(exp(1j*f['delta1']) * U[0, 1].conj())
+    return f
+
    + +
    +
    + +
    + + +
    +
    +

    def rephase_standard(

    UuL, UdL, UuR, UdR)

    +
    + + + + +

    Function to rephase the quark rotation matrices in order to +obtain the CKM matrix in standard parametrization.

    +

    The input matrices are assumed to diagonalize the up-type and down-type +quark matrices like

    +

    UuL.conj().T @ Mu @ UuR = Mu_diag +UdL.conj().T @ Md @ UdR = Md_diag

    +

    The CKM matrix is given as VCKM = UuL.conj().T @ UdL.

    +

    Returns a tuple with the rephased versions of the input matrices.

    +
    +

    Show source ≡

    +
    + 
    def rephase_standard(UuL, UdL, UuR, UdR):
+    """Function to rephase the quark rotation matrices in order to
+    obtain the CKM matrix in standard parametrization.
+
+    The input matrices are assumed to diagonalize the up-type and down-type
+    quark matrices like
+
+    ```
+    UuL.conj().T @ Mu @ UuR = Mu_diag
+    UdL.conj().T @ Md @ UdR = Md_diag
+    ```
+
+    The CKM matrix is given as `VCKM = UuL.conj().T @ UdL`.
+
+    Returns a tuple with the rephased versions of the input matrices.
+    """
+    K = UuL.conj().T @ UdL
+    f = mixing_phases(K)
+    Fdelta = np.diag(np.exp([1j*f['delta1'], 1j*f['delta2'], 1j*f['delta3']]))
+    Fphi = np.diag(np.exp([-1j*f['phi1']/2., -1j*f['phi2']/2., 0]))
+    return UuL @ Fdelta, UdL @ Fphi.conj(), UuR @ Fdelta, UdR @ Fphi.conj()
+
    + +
    +
    + +
    + + + +
    + +
    +
    + +
    + + + + + + diff --git a/docs/ckmutil/test_ckm.m.html b/docs/ckmutil/test_ckm.m.html index 36e0776..b38af82 100644 --- a/docs/ckmutil/test_ckm.m.html +++ b/docs/ckmutil/test_ckm.m.html @@ -1198,6 +1198,7 @@

    ckmutil.test_ckm module

    v_s = ckm_standard(t12, t13, t23, delta) v_w = ckm_wolfenstein(laC, A, rhobar, etabar) v_t = ckm_tree(Vus, Vub, Vcb, gamma) + v_wt = ckm_wolfenstein(*tree_to_wolfenstein(Vus, Vub, Vcb, gamma)) par_s = dict(t12=t12,t13=t13,t23=t23,delta=delta) par_w = dict(laC=laC,A=A,rhobar=rhobar,etabar=etabar) par_t = dict(Vus=Vus,Vub=Vub,Vcb=Vcb,gamma=gamma) @@ -1205,6 +1206,7 @@

    ckmutil.test_ckm module

    def test_ckm_parametrizations(self): np.testing.assert_almost_equal(self.v_t/self.v_s, np.ones((3,3)), decimal=5) np.testing.assert_almost_equal(self.v_t/self.v_w, np.ones((3,3)), decimal=5) + np.testing.assert_almost_equal(self.v_t/self.v_wt, np.ones((3,3)), decimal=5) def test_ckm_unitarity(self): np.testing.assert_almost_equal(np.dot(self.v_t,self.v_t.conj().T), np.eye(3), decimal=15) @@ -1378,6 +1380,7 @@

    Classes

    v_s = ckm_standard(t12, t13, t23, delta) v_w = ckm_wolfenstein(laC, A, rhobar, etabar) v_t = ckm_tree(Vus, Vub, Vcb, gamma) + v_wt = ckm_wolfenstein(*tree_to_wolfenstein(Vus, Vub, Vcb, gamma)) par_s = dict(t12=t12,t13=t13,t23=t23,delta=delta) par_w = dict(laC=laC,A=A,rhobar=rhobar,etabar=etabar) par_t = dict(Vus=Vus,Vub=Vub,Vcb=Vcb,gamma=gamma) @@ -1385,6 +1388,7 @@

    Classes

    def test_ckm_parametrizations(self): np.testing.assert_almost_equal(self.v_t/self.v_s, np.ones((3,3)), decimal=5) np.testing.assert_almost_equal(self.v_t/self.v_w, np.ones((3,3)), decimal=5) + np.testing.assert_almost_equal(self.v_t/self.v_wt, np.ones((3,3)), decimal=5) def test_ckm_unitarity(self): np.testing.assert_almost_equal(np.dot(self.v_t,self.v_t.conj().T), np.eye(3), decimal=15) @@ -1490,6 +1494,16 @@

    Class variables

    +
    +
    + + +
    +

    var v_wt

    + + + +
    @@ -3658,6 +3672,7 @@

    Static methods

    def test_ckm_parametrizations(self):
     np.testing.assert_almost_equal(self.v_t/self.v_s, np.ones((3,3)), decimal=5)
     np.testing.assert_almost_equal(self.v_t/self.v_w, np.ones((3,3)), decimal=5)
+    np.testing.assert_almost_equal(self.v_t/self.v_wt, np.ones((3,3)), decimal=5)
    diff --git a/docs/ckmutil/test_phases.m.html b/docs/ckmutil/test_phases.m.html new file mode 100644 index 0000000..aec8b70 --- /dev/null +++ b/docs/ckmutil/test_phases.m.html @@ -0,0 +1,3662 @@ + + + + + + ckmutil.test_phases API documentation + + + + + + + + + + + + + + + + + + + +Top + +
    + + + + +
    + + + + + + +
    +

    ckmutil.test_phases module

    + + +

    Show source ≡

    +
    + 
    import unittest
+import numpy.testing as npt
+from ckmutil.phases import *
+from ckmutil.ckm import ckm_standard
+from ckmutil.diag import msvd
+import numpy as np
+from math import sin, cos
+from cmath import exp
+
+# some auxiliary functions
+def diagonal_phase_matrix(a1, a2, a3):
+    r"""A diagonal $3\times 3$ matrix with $jj$-element $e^{i a_j}$"""
+    return np.diag(np.exp(1j*np.array([a1, a2, a3])))
+# general CKM/PMNS-like matrix
+def unitary_matrix(t12, t13, t23, delta, delta1, delta2, delta3, phi1, phi2):
+    ph1 = diagonal_phase_matrix(delta1, delta2, delta3)
+    ph2 = diagonal_phase_matrix(-phi1/2, -phi2/2, 0)
+    ckm = ckm_standard(t12, t13, t23, delta)
+    return np.dot(ph1, np.dot(ckm, ph2))
+
+class TestPhases(unittest.TestCase):
+    def test_rephasing(self):
+        # a random unitary matrix
+        U = np.array([[-0.4825-0.5529j,  0.6076-0.0129j,  0.1177+0.2798j],
+                   [ 0.1227-0.5748j, -0.1685-0.5786j, -0.2349-0.486j ],
+                   [-0.0755+0.3322j,  0.5157+0.0393j, -0.7321-0.2837j]])
+        f = mixing_phases(U)
+        # check that matrix reconstructed from extracted angles and phases
+        # coincides with original matrix
+        npt.assert_array_almost_equal(U, unitary_matrix(**f),
+            decimal=4)
+        # pathological case: unit matrix. Check that everything is zero
+        f = mixing_phases(np.eye(3))
+        for k, v in f.items():
+            self.assertEqual(v, 0, msg='{} is not zero'.format(k))
+        # random mass matrices
+        Mu = np.array([[ 0.6126+0.9819j,  0.0165+0.3709j,  0.0114+0.7819j],
+            [ 0.6374+0.8631j,  0.1249+0.8346j,  0.6940+0.4495j],
+            [ 0.1652+0.9667j,  0.4952+0.1281j,  0.7719+0.2325j]])
+        Md = np.array([[ 0.2874+0.2065j,  0.2210+0.9077j,  0.4053+0.454j ],
+            [ 0.0339+0.8332j,  0.5286+0.6339j,  0.3142+0.113j ],
+            [ 0.9379+0.2952j,  0.8488+0.634j ,  0.1413+0.9175j]])
+        UuL, Su, UuR = msvd(Mu)
+        UdL, Sd, UdR = msvd(Md)
+        f = mixing_phases(UuL.conj().T @ UdL)
+        UuL_, UdL_, UuR_, UdR_ = rephase_standard(UuL, UdL, UuR, UdR)
+        # rephased CKM
+        K = UuL_.conj().T @ UdL_
+        # CKM in standard parametrization
+        K_std = unitary_matrix(f['t12'], f['t13'], f['t23'], f['delta'], 0, 0, 0, 0, 0)
+        # ... should be equal!
+        npt.assert_array_almost_equal(K, K_std, decimal=10)
+
    + +
    + +
    + +
    + +

    Functions

    + +
    +
    +

    def diagonal_phase_matrix(

    a1, a2, a3)

    +
    + + + + +

    A diagonal $3\times 3$ matrix with $jj$-element $e^{i a_j}$

    +
    +

    Show source ≡

    +
    + 
    def diagonal_phase_matrix(a1, a2, a3):
+    r"""A diagonal $3\times 3$ matrix with $jj$-element $e^{i a_j}$"""
+    return np.diag(np.exp(1j*np.array([a1, a2, a3])))
+
    + +
    +
    + +
    + + +
    +
    +

    def unitary_matrix(

    t12, t13, t23, delta, delta1, delta2, delta3, phi1, phi2)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def unitary_matrix(t12, t13, t23, delta, delta1, delta2, delta3, phi1, phi2):
+    ph1 = diagonal_phase_matrix(delta1, delta2, delta3)
+    ph2 = diagonal_phase_matrix(-phi1/2, -phi2/2, 0)
+    ckm = ckm_standard(t12, t13, t23, delta)
+    return np.dot(ph1, np.dot(ckm, ph2))
+
    + +
    +
    + +
    + + +

    Classes

    + +
    +

    class TestPhases

    + + +

    A class whose instances are single test cases.

    +

    By default, the test code itself should be placed in a method named +'runTest'.

    +

    If the fixture may be used for many test cases, create as +many test methods as are needed. When instantiating such a TestCase +subclass, specify in the constructor arguments the name of the test method +that the instance is to execute.

    +

    Test authors should subclass TestCase for their own tests. Construction +and deconstruction of the test's environment ('fixture') can be +implemented by overriding the 'setUp' and 'tearDown' methods respectively.

    +

    If it is necessary to override the init method, the base class +init method must always be called. It is important that subclasses +should not change the signature of their init method, since instances +of the classes are instantiated automatically by parts of the framework +in order to be run.

    +

    When subclassing TestCase, you can set these attributes: + failureException: determines which exception will be raised when + the instance's assertion methods fail; test methods raising this + exception will be deemed to have 'failed' rather than 'errored'. + longMessage: determines whether long messages (including repr of + objects used in assert methods) will be printed on failure in addition + to any explicit message passed. +* maxDiff: sets the maximum length of a diff in failure messages + by assert methods using difflib. It is looked up as an instance + attribute so can be configured by individual tests if required.

    +
    +

    Show source ≡

    +
    + 
    class TestPhases(unittest.TestCase):
+    def test_rephasing(self):
+        # a random unitary matrix
+        U = np.array([[-0.4825-0.5529j,  0.6076-0.0129j,  0.1177+0.2798j],
+                   [ 0.1227-0.5748j, -0.1685-0.5786j, -0.2349-0.486j ],
+                   [-0.0755+0.3322j,  0.5157+0.0393j, -0.7321-0.2837j]])
+        f = mixing_phases(U)
+        # check that matrix reconstructed from extracted angles and phases
+        # coincides with original matrix
+        npt.assert_array_almost_equal(U, unitary_matrix(**f),
+            decimal=4)
+        # pathological case: unit matrix. Check that everything is zero
+        f = mixing_phases(np.eye(3))
+        for k, v in f.items():
+            self.assertEqual(v, 0, msg='{} is not zero'.format(k))
+        # random mass matrices
+        Mu = np.array([[ 0.6126+0.9819j,  0.0165+0.3709j,  0.0114+0.7819j],
+            [ 0.6374+0.8631j,  0.1249+0.8346j,  0.6940+0.4495j],
+            [ 0.1652+0.9667j,  0.4952+0.1281j,  0.7719+0.2325j]])
+        Md = np.array([[ 0.2874+0.2065j,  0.2210+0.9077j,  0.4053+0.454j ],
+            [ 0.0339+0.8332j,  0.5286+0.6339j,  0.3142+0.113j ],
+            [ 0.9379+0.2952j,  0.8488+0.634j ,  0.1413+0.9175j]])
+        UuL, Su, UuR = msvd(Mu)
+        UdL, Sd, UdR = msvd(Md)
+        f = mixing_phases(UuL.conj().T @ UdL)
+        UuL_, UdL_, UuR_, UdR_ = rephase_standard(UuL, UdL, UuR, UdR)
+        # rephased CKM
+        K = UuL_.conj().T @ UdL_
+        # CKM in standard parametrization
+        K_std = unitary_matrix(f['t12'], f['t13'], f['t23'], f['delta'], 0, 0, 0, 0, 0)
+        # ... should be equal!
+        npt.assert_array_almost_equal(K, K_std, decimal=10)
+
    + +
    +
    + + +
    +

    Ancestors (in MRO)

    +
      +
    • TestPhases
      • +
    • unittest.case.TestCase
      • +
    • builtins.object
      • +
    +

    Class variables

    +
    +

    var failureException

    + + + + +
    +
    + +
    +
    +

    var longMessage

    + + + + +
    +
    + +
    +
    +

    var maxDiff

    + + + + +
    +
    + +
    +

    Static methods

    + +
    +
    +

    def __init__(

    self, methodName='runTest')

    +
    + + + + +

    Create an instance of the class that will use the named test +method when executed. Raises a ValueError if the instance does +not have a method with the specified name.

    +
    +

    Show source ≡

    +
    + 
    def __init__(self, methodName='runTest'):
+    """Create an instance of the class that will use the named test
+       method when executed. Raises a ValueError if the instance does
+       not have a method with the specified name.
+    """
+    self._testMethodName = methodName
+    self._outcome = None
+    self._testMethodDoc = 'No test'
+    try:
+        testMethod = getattr(self, methodName)
+    except AttributeError:
+        if methodName != 'runTest':
+            # we allow instantiation with no explicit method name
+            # but not an *incorrect* or missing method name
+            raise ValueError("no such test method in %s: %s" %
+                  (self.__class__, methodName))
+    else:
+        self._testMethodDoc = testMethod.__doc__
+    self._cleanups = []
+    self._subtest = None
+    # Map types to custom assertEqual functions that will compare
+    # instances of said type in more detail to generate a more useful
+    # error message.
+    self._type_equality_funcs = {}
+    self.addTypeEqualityFunc(dict, 'assertDictEqual')
+    self.addTypeEqualityFunc(list, 'assertListEqual')
+    self.addTypeEqualityFunc(tuple, 'assertTupleEqual')
+    self.addTypeEqualityFunc(set, 'assertSetEqual')
+    self.addTypeEqualityFunc(frozenset, 'assertSetEqual')
+    self.addTypeEqualityFunc(str, 'assertMultiLineEqual')
+
    + +
    +
    + +
    + + +
    +
    +

    def addCleanup(

    self, function, *args, **kwargs)

    +
    + + + + +

    Add a function, with arguments, to be called when the test is +completed. Functions added are called on a LIFO basis and are +called after tearDown on test failure or success.

    +

    Cleanup items are called even if setUp fails (unlike tearDown).

    +
    +

    Show source ≡

    +
    + 
    def addCleanup(self, function, *args, **kwargs):
+    """Add a function, with arguments, to be called when the test is
+    completed. Functions added are called on a LIFO basis and are
+    called after tearDown on test failure or success.
+    Cleanup items are called even if setUp fails (unlike tearDown)."""
+    self._cleanups.append((function, args, kwargs))
+
    + +
    +
    + +
    + + +
    +
    +

    def addTypeEqualityFunc(

    self, typeobj, function)

    +
    + + + + +

    Add a type specific assertEqual style function to compare a type.

    +

    This method is for use by TestCase subclasses that need to register +their own type equality functions to provide nicer error messages.

    +

    Args: + typeobj: The data type to call this function on when both values + are of the same type in assertEqual(). + function: The callable taking two arguments and an optional + msg= argument that raises self.failureException with a + useful error message when the two arguments are not equal.

    +
    +

    Show source ≡

    +
    + 
    def addTypeEqualityFunc(self, typeobj, function):
+    """Add a type specific assertEqual style function to compare a type.
+    This method is for use by TestCase subclasses that need to register
+    their own type equality functions to provide nicer error messages.
+    Args:
+        typeobj: The data type to call this function on when both values
+                are of the same type in assertEqual().
+        function: The callable taking two arguments and an optional
+                msg= argument that raises self.failureException with a
+                useful error message when the two arguments are not equal.
+    """
+    self._type_equality_funcs[typeobj] = function
+
    + +
    +
    + +
    + + +
    +
    +

    def assertAlmostEqual(

    self, first, second, places=None, msg=None, delta=None)

    +
    + + + + +

    Fail if the two objects are unequal as determined by their +difference rounded to the given number of decimal places +(default 7) and comparing to zero, or by comparing that the +between the two objects is more than the given delta.

    +

    Note that decimal places (from zero) are usually not the same +as significant digits (measured from the most significant digit).

    +

    If the two objects compare equal then they will automatically +compare almost equal.

    +
    +

    Show source ≡

    +
    + 
    def assertAlmostEqual(self, first, second, places=None, msg=None,
+                      delta=None):
+    """Fail if the two objects are unequal as determined by their
+       difference rounded to the given number of decimal places
+       (default 7) and comparing to zero, or by comparing that the
+       between the two objects is more than the given delta.
+       Note that decimal places (from zero) are usually not the same
+       as significant digits (measured from the most significant digit).
+       If the two objects compare equal then they will automatically
+       compare almost equal.
+    """
+    if first == second:
+        # shortcut
+        return
+    if delta is not None and places is not None:
+        raise TypeError("specify delta or places not both")
+    if delta is not None:
+        if abs(first - second) <= delta:
+            return
+        standardMsg = '%s != %s within %s delta' % (safe_repr(first),
+                                                    safe_repr(second),
+                                                    safe_repr(delta))
+    else:
+        if places is None:
+            places = 7
+        if round(abs(second-first), places) == 0:
+            return
+        standardMsg = '%s != %s within %r places' % (safe_repr(first),
+                                                      safe_repr(second),
+                                                      places)
+    msg = self._formatMessage(msg, standardMsg)
+    raise self.failureException(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertAlmostEquals(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertCountEqual(

    self, first, second, msg=None)

    +
    + + + + +

    An unordered sequence comparison asserting that the same elements, +regardless of order. If the same element occurs more than once, +it verifies that the elements occur the same number of times.

    +
    self.assertEqual(Counter(list(first)),
+                 Counter(list(second)))
+
    + + +

    Example: + - [0, 1, 1] and [1, 0, 1] compare equal. + - [0, 0, 1] and [0, 1] compare unequal.

    +
    +

    Show source ≡

    +
    + 
    def assertCountEqual(self, first, second, msg=None):
+    """An unordered sequence comparison asserting that the same elements,
+    regardless of order.  If the same element occurs more than once,
+    it verifies that the elements occur the same number of times.
+        self.assertEqual(Counter(list(first)),
+                         Counter(list(second)))
+     Example:
+        - [0, 1, 1] and [1, 0, 1] compare equal.
+        - [0, 0, 1] and [0, 1] compare unequal.
+    """
+    first_seq, second_seq = list(first), list(second)
+    try:
+        first = collections.Counter(first_seq)
+        second = collections.Counter(second_seq)
+    except TypeError:
+        # Handle case with unhashable elements
+        differences = _count_diff_all_purpose(first_seq, second_seq)
+    else:
+        if first == second:
+            return
+        differences = _count_diff_hashable(first_seq, second_seq)
+    if differences:
+        standardMsg = 'Element counts were not equal:\n'
+        lines = ['First has %d, Second has %d:  %r' % diff for diff in differences]
+        diffMsg = '\n'.join(lines)
+        standardMsg = self._truncateMessage(standardMsg, diffMsg)
+        msg = self._formatMessage(msg, standardMsg)
+        self.fail(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertDictContainsSubset(

    self, subset, dictionary, msg=None)

    +
    + + + + +

    Checks whether dictionary is a superset of subset.

    +
    +

    Show source ≡

    +
    + 
    def assertDictContainsSubset(self, subset, dictionary, msg=None):
+    """Checks whether dictionary is a superset of subset."""
+    warnings.warn('assertDictContainsSubset is deprecated',
+                  DeprecationWarning)
+    missing = []
+    mismatched = []
+    for key, value in subset.items():
+        if key not in dictionary:
+            missing.append(key)
+        elif value != dictionary[key]:
+            mismatched.append('%s, expected: %s, actual: %s' %
+                              (safe_repr(key), safe_repr(value),
+                               safe_repr(dictionary[key])))
+    if not (missing or mismatched):
+        return
+    standardMsg = ''
+    if missing:
+        standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in
+                                                missing)
+    if mismatched:
+        if standardMsg:
+            standardMsg += '; '
+        standardMsg += 'Mismatched values: %s' % ','.join(mismatched)
+    self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertDictEqual(

    self, d1, d2, msg=None)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def assertDictEqual(self, d1, d2, msg=None):
+    self.assertIsInstance(d1, dict, 'First argument is not a dictionary')
+    self.assertIsInstance(d2, dict, 'Second argument is not a dictionary')
+    if d1 != d2:
+        standardMsg = '%s != %s' % _common_shorten_repr(d1, d2)
+        diff = ('\n' + '\n'.join(difflib.ndiff(
+                       pprint.pformat(d1).splitlines(),
+                       pprint.pformat(d2).splitlines())))
+        standardMsg = self._truncateMessage(standardMsg, diff)
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertEqual(

    self, first, second, msg=None)

    +
    + + + + +

    Fail if the two objects are unequal as determined by the '==' +operator.

    +
    +

    Show source ≡

    +
    + 
    def assertEqual(self, first, second, msg=None):
+    """Fail if the two objects are unequal as determined by the '=='
+       operator.
+    """
+    assertion_func = self._getAssertEqualityFunc(first, second)
+    assertion_func(first, second, msg=msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertEquals(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertFalse(

    self, expr, msg=None)

    +
    + + + + +

    Check that the expression is false.

    +
    +

    Show source ≡

    +
    + 
    def assertFalse(self, expr, msg=None):
+    """Check that the expression is false."""
+    if expr:
+        msg = self._formatMessage(msg, "%s is not false" % safe_repr(expr))
+        raise self.failureException(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertGreater(

    self, a, b, msg=None)

    +
    + + + + +

    Just like self.assertTrue(a > b), but with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertGreater(self, a, b, msg=None):
+    """Just like self.assertTrue(a > b), but with a nicer default message."""
+    if not a > b:
+        standardMsg = '%s not greater than %s' % (safe_repr(a), safe_repr(b))
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertGreaterEqual(

    self, a, b, msg=None)

    +
    + + + + +

    Just like self.assertTrue(a >= b), but with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertGreaterEqual(self, a, b, msg=None):
+    """Just like self.assertTrue(a >= b), but with a nicer default message."""
+    if not a >= b:
+        standardMsg = '%s not greater than or equal to %s' % (safe_repr(a), safe_repr(b))
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertIn(

    self, member, container, msg=None)

    +
    + + + + +

    Just like self.assertTrue(a in b), but with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertIn(self, member, container, msg=None):
+    """Just like self.assertTrue(a in b), but with a nicer default message."""
+    if member not in container:
+        standardMsg = '%s not found in %s' % (safe_repr(member),
+                                              safe_repr(container))
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertIs(

    self, expr1, expr2, msg=None)

    +
    + + + + +

    Just like self.assertTrue(a is b), but with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertIs(self, expr1, expr2, msg=None):
+    """Just like self.assertTrue(a is b), but with a nicer default message."""
+    if expr1 is not expr2:
+        standardMsg = '%s is not %s' % (safe_repr(expr1),
+                                         safe_repr(expr2))
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertIsInstance(

    self, obj, cls, msg=None)

    +
    + + + + +

    Same as self.assertTrue(isinstance(obj, cls)), with a nicer +default message.

    +
    +

    Show source ≡

    +
    + 
    def assertIsInstance(self, obj, cls, msg=None):
+    """Same as self.assertTrue(isinstance(obj, cls)), with a nicer
+    default message."""
+    if not isinstance(obj, cls):
+        standardMsg = '%s is not an instance of %r' % (safe_repr(obj), cls)
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertIsNone(

    self, obj, msg=None)

    +
    + + + + +

    Same as self.assertTrue(obj is None), with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertIsNone(self, obj, msg=None):
+    """Same as self.assertTrue(obj is None), with a nicer default message."""
+    if obj is not None:
+        standardMsg = '%s is not None' % (safe_repr(obj),)
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertIsNot(

    self, expr1, expr2, msg=None)

    +
    + + + + +

    Just like self.assertTrue(a is not b), but with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertIsNot(self, expr1, expr2, msg=None):
+    """Just like self.assertTrue(a is not b), but with a nicer default message."""
+    if expr1 is expr2:
+        standardMsg = 'unexpectedly identical: %s' % (safe_repr(expr1),)
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertIsNotNone(

    self, obj, msg=None)

    +
    + + + + +

    Included for symmetry with assertIsNone.

    +
    +

    Show source ≡

    +
    + 
    def assertIsNotNone(self, obj, msg=None):
+    """Included for symmetry with assertIsNone."""
+    if obj is None:
+        standardMsg = 'unexpectedly None'
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertLess(

    self, a, b, msg=None)

    +
    + + + + +

    Just like self.assertTrue(a < b), but with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertLess(self, a, b, msg=None):
+    """Just like self.assertTrue(a < b), but with a nicer default message."""
+    if not a < b:
+        standardMsg = '%s not less than %s' % (safe_repr(a), safe_repr(b))
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertLessEqual(

    self, a, b, msg=None)

    +
    + + + + +

    Just like self.assertTrue(a <= b), but with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertLessEqual(self, a, b, msg=None):
+    """Just like self.assertTrue(a <= b), but with a nicer default message."""
+    if not a <= b:
+        standardMsg = '%s not less than or equal to %s' % (safe_repr(a), safe_repr(b))
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertListEqual(

    self, list1, list2, msg=None)

    +
    + + + + +

    A list-specific equality assertion.

    +

    Args: + list1: The first list to compare. + list2: The second list to compare. + msg: Optional message to use on failure instead of a list of + differences.

    +
    +

    Show source ≡

    +
    + 
    def assertListEqual(self, list1, list2, msg=None):
+    """A list-specific equality assertion.
+    Args:
+        list1: The first list to compare.
+        list2: The second list to compare.
+        msg: Optional message to use on failure instead of a list of
+                differences.
+    """
+    self.assertSequenceEqual(list1, list2, msg, seq_type=list)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertLogs(

    self, logger=None, level=None)

    +
    + + + + +

    Fail unless a log message of level level or higher is emitted +on logger_name or its children. If omitted, level defaults to +INFO and logger defaults to the root logger.

    +

    This method must be used as a context manager, and will yield +a recording object with two attributes: output and records. +At the end of the context manager, the output attribute will +be a list of the matching formatted log messages and the +records attribute will be a list of the corresponding LogRecord +objects.

    +

    Example::

    +
    with self.assertLogs('foo', level='INFO') as cm:
+    logging.getLogger('foo').info('first message')
+    logging.getLogger('foo.bar').error('second message')
+self.assertEqual(cm.output, ['INFO:foo:first message',
+                             'ERROR:foo.bar:second message'])
+
    +
    +

    Show source ≡

    +
    + 
    def assertLogs(self, logger=None, level=None):
+    """Fail unless a log message of level *level* or higher is emitted
+    on *logger_name* or its children.  If omitted, *level* defaults to
+    INFO and *logger* defaults to the root logger.
+    This method must be used as a context manager, and will yield
+    a recording object with two attributes: `output` and `records`.
+    At the end of the context manager, the `output` attribute will
+    be a list of the matching formatted log messages and the
+    `records` attribute will be a list of the corresponding LogRecord
+    objects.
+    Example::
+        with self.assertLogs('foo', level='INFO') as cm:
+            logging.getLogger('foo').info('first message')
+            logging.getLogger('foo.bar').error('second message')
+        self.assertEqual(cm.output, ['INFO:foo:first message',
+                                     'ERROR:foo.bar:second message'])
+    """
+    return _AssertLogsContext(self, logger, level)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertMultiLineEqual(

    self, first, second, msg=None)

    +
    + + + + +

    Assert that two multi-line strings are equal.

    +
    +

    Show source ≡

    +
    + 
    def assertMultiLineEqual(self, first, second, msg=None):
+    """Assert that two multi-line strings are equal."""
+    self.assertIsInstance(first, str, 'First argument is not a string')
+    self.assertIsInstance(second, str, 'Second argument is not a string')
+    if first != second:
+        # don't use difflib if the strings are too long
+        if (len(first) > self._diffThreshold or
+            len(second) > self._diffThreshold):
+            self._baseAssertEqual(first, second, msg)
+        firstlines = first.splitlines(keepends=True)
+        secondlines = second.splitlines(keepends=True)
+        if len(firstlines) == 1 and first.strip('\r\n') == first:
+            firstlines = [first + '\n']
+            secondlines = [second + '\n']
+        standardMsg = '%s != %s' % _common_shorten_repr(first, second)
+        diff = '\n' + ''.join(difflib.ndiff(firstlines, secondlines))
+        standardMsg = self._truncateMessage(standardMsg, diff)
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertNotAlmostEqual(

    self, first, second, places=None, msg=None, delta=None)

    +
    + + + + +

    Fail if the two objects are equal as determined by their +difference rounded to the given number of decimal places +(default 7) and comparing to zero, or by comparing that the +between the two objects is less than the given delta.

    +

    Note that decimal places (from zero) are usually not the same +as significant digits (measured from the most significant digit).

    +

    Objects that are equal automatically fail.

    +
    +

    Show source ≡

    +
    + 
    def assertNotAlmostEqual(self, first, second, places=None, msg=None,
+                         delta=None):
+    """Fail if the two objects are equal as determined by their
+       difference rounded to the given number of decimal places
+       (default 7) and comparing to zero, or by comparing that the
+       between the two objects is less than the given delta.
+       Note that decimal places (from zero) are usually not the same
+       as significant digits (measured from the most significant digit).
+       Objects that are equal automatically fail.
+    """
+    if delta is not None and places is not None:
+        raise TypeError("specify delta or places not both")
+    if delta is not None:
+        if not (first == second) and abs(first - second) > delta:
+            return
+        standardMsg = '%s == %s within %s delta' % (safe_repr(first),
+                                                    safe_repr(second),
+                                                    safe_repr(delta))
+    else:
+        if places is None:
+            places = 7
+        if not (first == second) and round(abs(second-first), places) != 0:
+            return
+        standardMsg = '%s == %s within %r places' % (safe_repr(first),
+                                                     safe_repr(second),
+                                                     places)
+    msg = self._formatMessage(msg, standardMsg)
+    raise self.failureException(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertNotAlmostEquals(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertNotEqual(

    self, first, second, msg=None)

    +
    + + + + +

    Fail if the two objects are equal as determined by the '!=' +operator.

    +
    +

    Show source ≡

    +
    + 
    def assertNotEqual(self, first, second, msg=None):
+    """Fail if the two objects are equal as determined by the '!='
+       operator.
+    """
+    if not first != second:
+        msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first),
+                                                      safe_repr(second)))
+        raise self.failureException(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertNotEquals(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertNotIn(

    self, member, container, msg=None)

    +
    + + + + +

    Just like self.assertTrue(a not in b), but with a nicer default message.

    +
    +

    Show source ≡

    +
    + 
    def assertNotIn(self, member, container, msg=None):
+    """Just like self.assertTrue(a not in b), but with a nicer default message."""
+    if member in container:
+        standardMsg = '%s unexpectedly found in %s' % (safe_repr(member),
+                                                    safe_repr(container))
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertNotIsInstance(

    self, obj, cls, msg=None)

    +
    + + + + +

    Included for symmetry with assertIsInstance.

    +
    +

    Show source ≡

    +
    + 
    def assertNotIsInstance(self, obj, cls, msg=None):
+    """Included for symmetry with assertIsInstance."""
+    if isinstance(obj, cls):
+        standardMsg = '%s is an instance of %r' % (safe_repr(obj), cls)
+        self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertNotRegex(

    self, text, unexpected_regex, msg=None)

    +
    + + + + +

    Fail the test if the text matches the regular expression.

    +
    +

    Show source ≡

    +
    + 
    def assertNotRegex(self, text, unexpected_regex, msg=None):
+    """Fail the test if the text matches the regular expression."""
+    if isinstance(unexpected_regex, (str, bytes)):
+        unexpected_regex = re.compile(unexpected_regex)
+    match = unexpected_regex.search(text)
+    if match:
+        standardMsg = 'Regex matched: %r matches %r in %r' % (
+            text[match.start() : match.end()],
+            unexpected_regex.pattern,
+            text)
+        # _formatMessage ensures the longMessage option is respected
+        msg = self._formatMessage(msg, standardMsg)
+        raise self.failureException(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertNotRegexpMatches(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertRaises(

    self, expected_exception, *args, **kwargs)

    +
    + + + + +

    Fail unless an exception of class expected_exception is raised +by the callable when invoked with specified positional and +keyword arguments. If a different type of exception is +raised, it will not be caught, and the test case will be +deemed to have suffered an error, exactly as for an +unexpected exception.

    +

    If called with the callable and arguments omitted, will return a +context object used like this::

    +
     with self.assertRaises(SomeException):
+     do_something()
+
    + + +

    An optional keyword argument 'msg' can be provided when assertRaises +is used as a context object.

    +

    The context manager keeps a reference to the exception as +the 'exception' attribute. This allows you to inspect the +exception after the assertion::

    +
    with self.assertRaises(SomeException) as cm:
+    do_something()
+the_exception = cm.exception
+self.assertEqual(the_exception.error_code, 3)
+
    +
    +

    Show source ≡

    +
    + 
    def assertRaises(self, expected_exception, *args, **kwargs):
+    """Fail unless an exception of class expected_exception is raised
+       by the callable when invoked with specified positional and
+       keyword arguments. If a different type of exception is
+       raised, it will not be caught, and the test case will be
+       deemed to have suffered an error, exactly as for an
+       unexpected exception.
+       If called with the callable and arguments omitted, will return a
+       context object used like this::
+            with self.assertRaises(SomeException):
+                do_something()
+       An optional keyword argument 'msg' can be provided when assertRaises
+       is used as a context object.
+       The context manager keeps a reference to the exception as
+       the 'exception' attribute. This allows you to inspect the
+       exception after the assertion::
+           with self.assertRaises(SomeException) as cm:
+               do_something()
+           the_exception = cm.exception
+           self.assertEqual(the_exception.error_code, 3)
+    """
+    context = _AssertRaisesContext(expected_exception, self)
+    try:
+        return context.handle('assertRaises', args, kwargs)
+    finally:
+        # bpo-23890: manually break a reference cycle
+        context = None
+
    + +
    +
    + +
    + + +
    +
    +

    def assertRaisesRegex(

    self, expected_exception, expected_regex, *args, **kwargs)

    +
    + + + + +

    Asserts that the message in a raised exception matches a regex.

    +

    Args: + expected_exception: Exception class expected to be raised. + expected_regex: Regex (re pattern object or string) expected + to be found in error message. + args: Function to be called and extra positional args. + kwargs: Extra kwargs. + msg: Optional message used in case of failure. Can only be used + when assertRaisesRegex is used as a context manager.

    +
    +

    Show source ≡

    +
    + 
    def assertRaisesRegex(self, expected_exception, expected_regex,
+                      *args, **kwargs):
+    """Asserts that the message in a raised exception matches a regex.
+    Args:
+        expected_exception: Exception class expected to be raised.
+        expected_regex: Regex (re pattern object or string) expected
+                to be found in error message.
+        args: Function to be called and extra positional args.
+        kwargs: Extra kwargs.
+        msg: Optional message used in case of failure. Can only be used
+                when assertRaisesRegex is used as a context manager.
+    """
+    context = _AssertRaisesContext(expected_exception, self, expected_regex)
+    return context.handle('assertRaisesRegex', args, kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertRaisesRegexp(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertRegex(

    self, text, expected_regex, msg=None)

    +
    + + + + +

    Fail the test unless the text matches the regular expression.

    +
    +

    Show source ≡

    +
    + 
    def assertRegex(self, text, expected_regex, msg=None):
+    """Fail the test unless the text matches the regular expression."""
+    if isinstance(expected_regex, (str, bytes)):
+        assert expected_regex, "expected_regex must not be empty."
+        expected_regex = re.compile(expected_regex)
+    if not expected_regex.search(text):
+        standardMsg = "Regex didn't match: %r not found in %r" % (
+            expected_regex.pattern, text)
+        # _formatMessage ensures the longMessage option is respected
+        msg = self._formatMessage(msg, standardMsg)
+        raise self.failureException(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertRegexpMatches(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertSequenceEqual(

    self, seq1, seq2, msg=None, seq_type=None)

    +
    + + + + +

    An equality assertion for ordered sequences (like lists and tuples).

    +

    For the purposes of this function, a valid ordered sequence type is one +which can be indexed, has a length, and has an equality operator.

    +

    Args: + seq1: The first sequence to compare. + seq2: The second sequence to compare. + seq_type: The expected datatype of the sequences, or None if no + datatype should be enforced. + msg: Optional message to use on failure instead of a list of + differences.

    +
    +

    Show source ≡

    +
    + 
    def assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):
+    """An equality assertion for ordered sequences (like lists and tuples).
+    For the purposes of this function, a valid ordered sequence type is one
+    which can be indexed, has a length, and has an equality operator.
+    Args:
+        seq1: The first sequence to compare.
+        seq2: The second sequence to compare.
+        seq_type: The expected datatype of the sequences, or None if no
+                datatype should be enforced.
+        msg: Optional message to use on failure instead of a list of
+                differences.
+    """
+    if seq_type is not None:
+        seq_type_name = seq_type.__name__
+        if not isinstance(seq1, seq_type):
+            raise self.failureException('First sequence is not a %s: %s'
+                                    % (seq_type_name, safe_repr(seq1)))
+        if not isinstance(seq2, seq_type):
+            raise self.failureException('Second sequence is not a %s: %s'
+                                    % (seq_type_name, safe_repr(seq2)))
+    else:
+        seq_type_name = "sequence"
+    differing = None
+    try:
+        len1 = len(seq1)
+    except (TypeError, NotImplementedError):
+        differing = 'First %s has no length.    Non-sequence?' % (
+                seq_type_name)
+    if differing is None:
+        try:
+            len2 = len(seq2)
+        except (TypeError, NotImplementedError):
+            differing = 'Second %s has no length.    Non-sequence?' % (
+                    seq_type_name)
+    if differing is None:
+        if seq1 == seq2:
+            return
+        differing = '%ss differ: %s != %s\n' % (
+                (seq_type_name.capitalize(),) +
+                _common_shorten_repr(seq1, seq2))
+        for i in range(min(len1, len2)):
+            try:
+                item1 = seq1[i]
+            except (TypeError, IndexError, NotImplementedError):
+                differing += ('\nUnable to index element %d of first %s\n' %
+                             (i, seq_type_name))
+                break
+            try:
+                item2 = seq2[i]
+            except (TypeError, IndexError, NotImplementedError):
+                differing += ('\nUnable to index element %d of second %s\n' %
+                             (i, seq_type_name))
+                break
+            if item1 != item2:
+                differing += ('\nFirst differing element %d:\n%s\n%s\n' %
+                             ((i,) + _common_shorten_repr(item1, item2)))
+                break
+        else:
+            if (len1 == len2 and seq_type is None and
+                type(seq1) != type(seq2)):
+                # The sequences are the same, but have differing types.
+                return
+        if len1 > len2:
+            differing += ('\nFirst %s contains %d additional '
+                         'elements.\n' % (seq_type_name, len1 - len2))
+            try:
+                differing += ('First extra element %d:\n%s\n' %
+                              (len2, safe_repr(seq1[len2])))
+            except (TypeError, IndexError, NotImplementedError):
+                differing += ('Unable to index element %d '
+                              'of first %s\n' % (len2, seq_type_name))
+        elif len1 < len2:
+            differing += ('\nSecond %s contains %d additional '
+                         'elements.\n' % (seq_type_name, len2 - len1))
+            try:
+                differing += ('First extra element %d:\n%s\n' %
+                              (len1, safe_repr(seq2[len1])))
+            except (TypeError, IndexError, NotImplementedError):
+                differing += ('Unable to index element %d '
+                              'of second %s\n' % (len1, seq_type_name))
+    standardMsg = differing
+    diffMsg = '\n' + '\n'.join(
+        difflib.ndiff(pprint.pformat(seq1).splitlines(),
+                      pprint.pformat(seq2).splitlines()))
+    standardMsg = self._truncateMessage(standardMsg, diffMsg)
+    msg = self._formatMessage(msg, standardMsg)
+    self.fail(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertSetEqual(

    self, set1, set2, msg=None)

    +
    + + + + +

    A set-specific equality assertion.

    +

    Args: + set1: The first set to compare. + set2: The second set to compare. + msg: Optional message to use on failure instead of a list of + differences.

    +

    assertSetEqual uses ducktyping to support different types of sets, and +is optimized for sets specifically (parameters must support a +difference method).

    +
    +

    Show source ≡

    +
    + 
    def assertSetEqual(self, set1, set2, msg=None):
+    """A set-specific equality assertion.
+    Args:
+        set1: The first set to compare.
+        set2: The second set to compare.
+        msg: Optional message to use on failure instead of a list of
+                differences.
+    assertSetEqual uses ducktyping to support different types of sets, and
+    is optimized for sets specifically (parameters must support a
+    difference method).
+    """
+    try:
+        difference1 = set1.difference(set2)
+    except TypeError as e:
+        self.fail('invalid type when attempting set difference: %s' % e)
+    except AttributeError as e:
+        self.fail('first argument does not support set difference: %s' % e)
+    try:
+        difference2 = set2.difference(set1)
+    except TypeError as e:
+        self.fail('invalid type when attempting set difference: %s' % e)
+    except AttributeError as e:
+        self.fail('second argument does not support set difference: %s' % e)
+    if not (difference1 or difference2):
+        return
+    lines = []
+    if difference1:
+        lines.append('Items in the first set but not the second:')
+        for item in difference1:
+            lines.append(repr(item))
+    if difference2:
+        lines.append('Items in the second set but not the first:')
+        for item in difference2:
+            lines.append(repr(item))
+    standardMsg = '\n'.join(lines)
+    self.fail(self._formatMessage(msg, standardMsg))
+
    + +
    +
    + +
    + + +
    +
    +

    def assertTrue(

    self, expr, msg=None)

    +
    + + + + +

    Check that the expression is true.

    +
    +

    Show source ≡

    +
    + 
    def assertTrue(self, expr, msg=None):
+    """Check that the expression is true."""
+    if not expr:
+        msg = self._formatMessage(msg, "%s is not true" % safe_repr(expr))
+        raise self.failureException(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertTupleEqual(

    self, tuple1, tuple2, msg=None)

    +
    + + + + +

    A tuple-specific equality assertion.

    +

    Args: + tuple1: The first tuple to compare. + tuple2: The second tuple to compare. + msg: Optional message to use on failure instead of a list of + differences.

    +
    +

    Show source ≡

    +
    + 
    def assertTupleEqual(self, tuple1, tuple2, msg=None):
+    """A tuple-specific equality assertion.
+    Args:
+        tuple1: The first tuple to compare.
+        tuple2: The second tuple to compare.
+        msg: Optional message to use on failure instead of a list of
+                differences.
+    """
+    self.assertSequenceEqual(tuple1, tuple2, msg, seq_type=tuple)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertWarns(

    self, expected_warning, *args, **kwargs)

    +
    + + + + +

    Fail unless a warning of class warnClass is triggered +by the callable when invoked with specified positional and +keyword arguments. If a different type of warning is +triggered, it will not be handled: depending on the other +warning filtering rules in effect, it might be silenced, printed +out, or raised as an exception.

    +

    If called with the callable and arguments omitted, will return a +context object used like this::

    +
     with self.assertWarns(SomeWarning):
+     do_something()
+
    + + +

    An optional keyword argument 'msg' can be provided when assertWarns +is used as a context object.

    +

    The context manager keeps a reference to the first matching +warning as the 'warning' attribute; similarly, the 'filename' +and 'lineno' attributes give you information about the line +of Python code from which the warning was triggered. +This allows you to inspect the warning after the assertion::

    +
    with self.assertWarns(SomeWarning) as cm:
+    do_something()
+the_warning = cm.warning
+self.assertEqual(the_warning.some_attribute, 147)
+
    +
    +

    Show source ≡

    +
    + 
    def assertWarns(self, expected_warning, *args, **kwargs):
+    """Fail unless a warning of class warnClass is triggered
+       by the callable when invoked with specified positional and
+       keyword arguments.  If a different type of warning is
+       triggered, it will not be handled: depending on the other
+       warning filtering rules in effect, it might be silenced, printed
+       out, or raised as an exception.
+       If called with the callable and arguments omitted, will return a
+       context object used like this::
+            with self.assertWarns(SomeWarning):
+                do_something()
+       An optional keyword argument 'msg' can be provided when assertWarns
+       is used as a context object.
+       The context manager keeps a reference to the first matching
+       warning as the 'warning' attribute; similarly, the 'filename'
+       and 'lineno' attributes give you information about the line
+       of Python code from which the warning was triggered.
+       This allows you to inspect the warning after the assertion::
+           with self.assertWarns(SomeWarning) as cm:
+               do_something()
+           the_warning = cm.warning
+           self.assertEqual(the_warning.some_attribute, 147)
+    """
+    context = _AssertWarnsContext(expected_warning, self)
+    return context.handle('assertWarns', args, kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assertWarnsRegex(

    self, expected_warning, expected_regex, *args, **kwargs)

    +
    + + + + +

    Asserts that the message in a triggered warning matches a regexp. +Basic functioning is similar to assertWarns() with the addition +that only warnings whose messages also match the regular expression +are considered successful matches.

    +

    Args: + expected_warning: Warning class expected to be triggered. + expected_regex: Regex (re pattern object or string) expected + to be found in error message. + args: Function to be called and extra positional args. + kwargs: Extra kwargs. + msg: Optional message used in case of failure. Can only be used + when assertWarnsRegex is used as a context manager.

    +
    +

    Show source ≡

    +
    + 
    def assertWarnsRegex(self, expected_warning, expected_regex,
+                     *args, **kwargs):
+    """Asserts that the message in a triggered warning matches a regexp.
+    Basic functioning is similar to assertWarns() with the addition
+    that only warnings whose messages also match the regular expression
+    are considered successful matches.
+    Args:
+        expected_warning: Warning class expected to be triggered.
+        expected_regex: Regex (re pattern object or string) expected
+                to be found in error message.
+        args: Function to be called and extra positional args.
+        kwargs: Extra kwargs.
+        msg: Optional message used in case of failure. Can only be used
+                when assertWarnsRegex is used as a context manager.
+    """
+    context = _AssertWarnsContext(expected_warning, self, expected_regex)
+    return context.handle('assertWarnsRegex', args, kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def assert_(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def countTestCases(

    self)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def countTestCases(self):
+    return 1
+
    + +
    +
    + +
    + + +
    +
    +

    def debug(

    self)

    +
    + + + + +

    Run the test without collecting errors in a TestResult

    +
    +

    Show source ≡

    +
    + 
    def debug(self):
+    """Run the test without collecting errors in a TestResult"""
+    self.setUp()
+    getattr(self, self._testMethodName)()
+    self.tearDown()
+    while self._cleanups:
+        function, args, kwargs = self._cleanups.pop(-1)
+        function(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def defaultTestResult(

    self)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def defaultTestResult(self):
+    return result.TestResult()
+
    + +
    +
    + +
    + + +
    +
    +

    def doCleanups(

    self)

    +
    + + + + +

    Execute all cleanup functions. Normally called for you after +tearDown.

    +
    +

    Show source ≡

    +
    + 
    def doCleanups(self):
+    """Execute all cleanup functions. Normally called for you after
+    tearDown."""
+    outcome = self._outcome or _Outcome()
+    while self._cleanups:
+        function, args, kwargs = self._cleanups.pop()
+        with outcome.testPartExecutor(self):
+            function(*args, **kwargs)
+    # return this for backwards compatibility
+    # even though we no longer us it internally
+    return outcome.success
+
    + +
    +
    + +
    + + +
    +
    +

    def fail(

    self, msg=None)

    +
    + + + + +

    Fail immediately, with the given message.

    +
    +

    Show source ≡

    +
    + 
    def fail(self, msg=None):
+    """Fail immediately, with the given message."""
+    raise self.failureException(msg)
+
    + +
    +
    + +
    + + +
    +
    +

    def failIf(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def failIfAlmostEqual(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def failIfEqual(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def failUnless(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def failUnlessAlmostEqual(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def failUnlessEqual(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def failUnlessRaises(

    *args, **kwargs)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def deprecated_func(*args, **kwargs):
+    warnings.warn(
+        'Please use {0} instead.'.format(original_func.__name__),
+        DeprecationWarning, 2)
+    return original_func(*args, **kwargs)
+
    + +
    +
    + +
    + + +
    +
    +

    def id(

    self)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def id(self):
+    return "%s.%s" % (strclass(self.__class__), self._testMethodName)
+
    + +
    +
    + +
    + + +
    +
    +

    def run(

    self, result=None)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def run(self, result=None):
+    orig_result = result
+    if result is None:
+        result = self.defaultTestResult()
+        startTestRun = getattr(result, 'startTestRun', None)
+        if startTestRun is not None:
+            startTestRun()
+    result.startTest(self)
+    testMethod = getattr(self, self._testMethodName)
+    if (getattr(self.__class__, "__unittest_skip__", False) or
+        getattr(testMethod, "__unittest_skip__", False)):
+        # If the class or method was skipped.
+        try:
+            skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')
+                        or getattr(testMethod, '__unittest_skip_why__', ''))
+            self._addSkip(result, self, skip_why)
+        finally:
+            result.stopTest(self)
+        return
+    expecting_failure_method = getattr(testMethod,
+                                       "__unittest_expecting_failure__", False)
+    expecting_failure_class = getattr(self,
+                                      "__unittest_expecting_failure__", False)
+    expecting_failure = expecting_failure_class or expecting_failure_method
+    outcome = _Outcome(result)
+    try:
+        self._outcome = outcome
+        with outcome.testPartExecutor(self):
+            self.setUp()
+        if outcome.success:
+            outcome.expecting_failure = expecting_failure
+            with outcome.testPartExecutor(self, isTest=True):
+                testMethod()
+            outcome.expecting_failure = False
+            with outcome.testPartExecutor(self):
+                self.tearDown()
+        self.doCleanups()
+        for test, reason in outcome.skipped:
+            self._addSkip(result, test, reason)
+        self._feedErrorsToResult(result, outcome.errors)
+        if outcome.success:
+            if expecting_failure:
+                if outcome.expectedFailure:
+                    self._addExpectedFailure(result, outcome.expectedFailure)
+                else:
+                    self._addUnexpectedSuccess(result)
+            else:
+                result.addSuccess(self)
+        return result
+    finally:
+        result.stopTest(self)
+        if orig_result is None:
+            stopTestRun = getattr(result, 'stopTestRun', None)
+            if stopTestRun is not None:
+                stopTestRun()
+        # explicitly break reference cycles:
+        # outcome.errors -> frame -> outcome -> outcome.errors
+        # outcome.expectedFailure -> frame -> outcome -> outcome.expectedFailure
+        outcome.errors.clear()
+        outcome.expectedFailure = None
+        # clear the outcome, no more needed
+        self._outcome = None
+
    + +
    +
    + +
    + + +
    +
    +

    def setUp(

    self)

    +
    + + + + +

    Hook method for setting up the test fixture before exercising it.

    +
    +

    Show source ≡

    +
    + 
    def setUp(self):
+    "Hook method for setting up the test fixture before exercising it."
+    pass
+
    + +
    +
    + +
    + + +
    +
    +

    def shortDescription(

    self)

    +
    + + + + +

    Returns a one-line description of the test, or None if no +description has been provided.

    +

    The default implementation of this method returns the first line of +the specified test method's docstring.

    +
    +

    Show source ≡

    +
    + 
    def shortDescription(self):
+    """Returns a one-line description of the test, or None if no
+    description has been provided.
+    The default implementation of this method returns the first line of
+    the specified test method's docstring.
+    """
+    doc = self._testMethodDoc
+    return doc and doc.split("\n")[0].strip() or None
+
    + +
    +
    + +
    + + +
    +
    +

    def skipTest(

    self, reason)

    +
    + + + + +

    Skip this test.

    +
    +

    Show source ≡

    +
    + 
    def skipTest(self, reason):
+    """Skip this test."""
+    raise SkipTest(reason)
+
    + +
    +
    + +
    + + +
    +
    +

    def subTest(

    *args, **kwds)

    +
    + + + + +

    Return a context manager that will return the enclosed block +of code in a subtest identified by the optional message and +keyword parameters. A failure in the subtest marks the test +case as failed but resumes execution at the end of the enclosed +block, allowing further test code to be executed.

    +
    +

    Show source ≡

    +
    + 
    @contextlib.contextmanager
+def subTest(self, msg=_subtest_msg_sentinel, **params):
+    """Return a context manager that will return the enclosed block
+    of code in a subtest identified by the optional message and
+    keyword parameters.  A failure in the subtest marks the test
+    case as failed but resumes execution at the end of the enclosed
+    block, allowing further test code to be executed.
+    """
+    if not self._outcome.result_supports_subtests:
+        yield
+        return
+    parent = self._subtest
+    if parent is None:
+        params_map = collections.ChainMap(params)
+    else:
+        params_map = parent.params.new_child(params)
+    self._subtest = _SubTest(self, msg, params_map)
+    try:
+        with self._outcome.testPartExecutor(self._subtest, isTest=True):
+            yield
+        if not self._outcome.success:
+            result = self._outcome.result
+            if result is not None and result.failfast:
+                raise _ShouldStop
+        elif self._outcome.expectedFailure:
+            # If the test is expecting a failure, we really want to
+            # stop now and register the expected failure.
+            raise _ShouldStop
+    finally:
+        self._subtest = parent
+
    + +
    +
    + +
    + + +
    +
    +

    def tearDown(

    self)

    +
    + + + + +

    Hook method for deconstructing the test fixture after testing it.

    +
    +

    Show source ≡

    +
    + 
    def tearDown(self):
+    "Hook method for deconstructing the test fixture after testing it."
+    pass
+
    + +
    +
    + +
    + + +
    +
    +

    def test_rephasing(

    self)

    +
    + + + + +
    +

    Show source ≡

    +
    + 
    def test_rephasing(self):
+    # a random unitary matrix
+    U = np.array([[-0.4825-0.5529j,  0.6076-0.0129j,  0.1177+0.2798j],
+               [ 0.1227-0.5748j, -0.1685-0.5786j, -0.2349-0.486j ],
+               [-0.0755+0.3322j,  0.5157+0.0393j, -0.7321-0.2837j]])
+    f = mixing_phases(U)
+    # check that matrix reconstructed from extracted angles and phases
+    # coincides with original matrix
+    npt.assert_array_almost_equal(U, unitary_matrix(**f),
+        decimal=4)
+    # pathological case: unit matrix. Check that everything is zero
+    f = mixing_phases(np.eye(3))
+    for k, v in f.items():
+        self.assertEqual(v, 0, msg='{} is not zero'.format(k))
+    # random mass matrices
+    Mu = np.array([[ 0.6126+0.9819j,  0.0165+0.3709j,  0.0114+0.7819j],
+        [ 0.6374+0.8631j,  0.1249+0.8346j,  0.6940+0.4495j],
+        [ 0.1652+0.9667j,  0.4952+0.1281j,  0.7719+0.2325j]])
+    Md = np.array([[ 0.2874+0.2065j,  0.2210+0.9077j,  0.4053+0.454j ],
+        [ 0.0339+0.8332j,  0.5286+0.6339j,  0.3142+0.113j ],
+        [ 0.9379+0.2952j,  0.8488+0.634j ,  0.1413+0.9175j]])
+    UuL, Su, UuR = msvd(Mu)
+    UdL, Sd, UdR = msvd(Md)
+    f = mixing_phases(UuL.conj().T @ UdL)
+    UuL_, UdL_, UuR_, UdR_ = rephase_standard(UuL, UdL, UuR, UdR)
+    # rephased CKM
+    K = UuL_.conj().T @ UdL_
+    # CKM in standard parametrization
+    K_std = unitary_matrix(f['t12'], f['t13'], f['t23'], f['delta'], 0, 0, 0, 0, 0)
+    # ... should be equal!
+    npt.assert_array_almost_equal(K, K_std, decimal=10)
+
    + +
    +
    + +
    + +

    Methods

    + +
    +
    +

    def setUpClass(

    cls)

    +
    + + + + +

    Hook method for setting up class fixture before running tests in the class.

    +
    +

    Show source ≡

    +
    + 
    @classmethod
+def setUpClass(cls):
+    "Hook method for setting up class fixture before running tests in the class."
+
    + +
    +
    + +
    + + +
    +
    +

    def tearDownClass(

    cls)

    +
    + + + + +

    Hook method for deconstructing the class fixture after running all tests in the class.

    +
    +

    Show source ≡

    +
    + 
    @classmethod
+def tearDownClass(cls):
+    "Hook method for deconstructing the class fixture after running all tests in the class."
+
    + +
    +
    + +
    + +
    +
    + +
    + +
    +
    + +
    + + + + + +