TransportMaps.tests.test_transportmap_distributions

Module Contents

Classes

TransportMapDistribution_DerivativeChecks
PullBackTMD_DerivativeChecks
PushForwardTMD_DerivativeChecks
IntegratedExponential
IntegratedExponentialPBTMD_DerivativeChecks
IntegratedExponentialPFTMD_DerivativeChecks
CommonBasisIntegratedExponential
CommonBasisIntegratedExponentialPBTMD_DerivativeChecks
CommonBasisIntegratedExponentialPFTMD_DerivativeChecks
TotOrdIntegratedExponential
TotOrdIntegratedExponentialPBTMD_DerivativeChecks
TotOrdIntegratedExponentialPFTMD_DerivativeChecks
CommonBasisTotOrdIntegratedExponential
CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks
CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks
IntegratedSquared
IntegratedSquaredPBTMD_DerivativeChecks
IntegratedSquaredPFTMD_DerivativeChecks
TotOrdIntegratedSquared
TotOrdIntegratedSquaredPBTMD_DerivativeChecks
TotOrdIntegratedSquaredPFTMD_DerivativeChecks
LinearSpanPBTMD_DerivativeChecks
CommonBasisLinearSpanPBTMD_DerivativeChecks
TMD_TestCase
Linear1D_TMD_TestCase
ArcTan1D_TMD_TestCase
Exp1D_TMD_TestCase
Logistic1D_TMD_TestCase
Gamma1D_TMD_TestCase
Beta1D_TMD_TestCase
Gumbel1D_TMD_TestCase
Linear2D_TMD_TestCase
Banana2D_TMD_TestCase
Linear1D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_IEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_CBIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_TOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_CBTOIEPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_IEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_CBIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_TOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_CBTOIEPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_ISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_TOISPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_ISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
ArcTan1D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Exp1D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Logistic1D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gamma1D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Beta1D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Gumbel1D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear2D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Banana2D_TOISPFTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_LSPBTMD_DerivativeChecks	A class whose instances are single test cases.
Linear1D_CBLSPBTMD_DerivativeChecks	A class whose instances are single test cases.

Functions

build_suite([ttype])
run_tests([ttype, failfast])

Attributes

MPI_SUPPORT

TransportMaps.tests.test_transportmap_distributions.MPI_SUPPORT = True

class TransportMaps.tests.test_transportmap_distributions.TransportMapDistribution_DerivativeChecks

Bases: object

setUp()

test_test_gradients()

test_log_pdf()

test_grad_a_log_pdf()

test_tuple_grad_a_log_pdf()

test_hess_a_log_pdf()

test_action_hess_a_log_pdf()

test_grad_x_log_pdf()

test_hess_x_log_pdf()

class TransportMaps.tests.test_transportmap_distributions.PullBackTMD_DerivativeChecks

Bases: TransportMapDistribution_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.PushForwardTMD_DerivativeChecks

Bases: TransportMapDistribution_DerivativeChecks

setUp()

test_tuple_grad_a_log_pdf()

test_hess_a_log_pdf()

test_action_hess_a_log_pdf()

test_test_gradients()

test_grad_x_log_pdf()

test_hess_x_log_pdf()

class TransportMaps.tests.test_transportmap_distributions.IntegratedExponential

setUpApprox()

class TransportMaps.tests.test_transportmap_distributions.IntegratedExponentialPBTMD_DerivativeChecks

Bases: IntegratedExponential, PullBackTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.IntegratedExponentialPFTMD_DerivativeChecks

Bases: IntegratedExponential, PushForwardTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.CommonBasisIntegratedExponential

setUpApprox()

class TransportMaps.tests.test_transportmap_distributions.CommonBasisIntegratedExponentialPBTMD_DerivativeChecks

Bases: CommonBasisIntegratedExponential, PullBackTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.CommonBasisIntegratedExponentialPFTMD_DerivativeChecks

Bases: CommonBasisIntegratedExponential, PushForwardTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.TotOrdIntegratedExponential

setUpApprox()

class TransportMaps.tests.test_transportmap_distributions.TotOrdIntegratedExponentialPBTMD_DerivativeChecks

Bases: TotOrdIntegratedExponential, PullBackTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.TotOrdIntegratedExponentialPFTMD_DerivativeChecks

Bases: TotOrdIntegratedExponential, PushForwardTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.CommonBasisTotOrdIntegratedExponential

setUpApprox()

class TransportMaps.tests.test_transportmap_distributions.CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks

Bases: CommonBasisTotOrdIntegratedExponential, PullBackTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks

Bases: CommonBasisTotOrdIntegratedExponential, PushForwardTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.IntegratedSquared

setUpApprox()

class TransportMaps.tests.test_transportmap_distributions.IntegratedSquaredPBTMD_DerivativeChecks

Bases: IntegratedSquared, PullBackTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.IntegratedSquaredPFTMD_DerivativeChecks

Bases: IntegratedSquared, PushForwardTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.TotOrdIntegratedSquared

setUpApprox()

class TransportMaps.tests.test_transportmap_distributions.TotOrdIntegratedSquaredPBTMD_DerivativeChecks

Bases: TotOrdIntegratedSquared, PullBackTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.TotOrdIntegratedSquaredPFTMD_DerivativeChecks

Bases: TotOrdIntegratedSquared, PushForwardTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.LinearSpanPBTMD_DerivativeChecks

Bases: PullBackTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.CommonBasisLinearSpanPBTMD_DerivativeChecks

Bases: PullBackTMD_DerivativeChecks

setUp()

class TransportMaps.tests.test_transportmap_distributions.TMD_TestCase

Bases: object

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Linear1D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Exp1D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Beta1D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Linear2D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Banana2D_TMD_TestCase

Bases: TMD_TestCase

_setUp_tcase()

class TransportMaps.tests.test_transportmap_distributions.Linear1D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_IEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, IntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_CBIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, CommonBasisIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_TOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, TotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_CBTOIEPBTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_IEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, IntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_CBIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, CommonBasisIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_TOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, TotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_CBTOIEPFTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, CommonBasisTotOrdIntegratedExponentialPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_ISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, IntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_TOISPBTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, TotOrdIntegratedSquaredPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_ISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, IntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.ArcTan1D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: ArcTan1D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Exp1D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Exp1D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Logistic1D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Logistic1D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gamma1D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gamma1D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Beta1D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Beta1D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Gumbel1D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Gumbel1D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear2D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Linear2D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Banana2D_TOISPFTMD_DerivativeChecks(methodName='runTest')

Bases: Banana2D_TMD_TestCase, TotOrdIntegratedSquaredPFTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_LSPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, LinearSpanPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

class TransportMaps.tests.test_transportmap_distributions.Linear1D_CBLSPBTMD_DerivativeChecks(methodName='runTest')

Bases: Linear1D_TMD_TestCase, CommonBasisLinearSpanPBTMD_DerivativeChecks, unittest.TestCase

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.

setUp()

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

TransportMaps.tests.test_transportmap_distributions.build_suite(ttype='all')

TransportMaps.tests.test_transportmap_distributions.run_tests(ttype='serial', failfast=False)