Example 1 - “subtype”:

Use a lambda if too long.

from liskov import subtype

BasicCalc = lambda: subtype('testCalc.BasicCalcTest')
BaseConverter = lambda: subtype('testConvert.BaseConverterTest')
class ScientificCalcTest(BasicCalc(), BaseConverter()):
  def test_it_is_a_subtype_of_BasicCalc(self):
    from testCalc import BasicCalcTest
    assert isinstance(self, BasicCalcTest)

  def test_it_is_a_subtype_of_BaseConverter(self):
    from testConvert import BaseConverterTest
    assert isinstance(self, BaseConverterTest)

Example 2 - “behave_as”:

Python 2 version

from liskov import behave_as

class ScientificCalcTest(object):
  __metaclass__ = behave_as('testCalc.BasicCalcTest', 'testConvert.BaseConverterTest')

  def test_it_is_a_subtype_of_BasicCalc(self):
    from testCalc import BasicCalcTest
    assert isinstance(self, BasicCalcTest)

  def test_it_is_a_subtype_of_BaseConverter(self):
    from testConvert import BaseConverterTest
    assert isinstance(self, BaseConverterTest)

Python 3 version

from liskov import behave_as

metaclass = behave_as('testCalc.BasicCalcTest', 'testConvert.BaseConverterTest')

class ScientificCalcTest(object, metaclass=metaclass):
  def test_it_is_a_subtype_of_BasicCalc(self):
    from testCalc import BasicCalcTest
    assert isinstance(self, BasicCalcTest)

  def test_it_is_a_subtype_of_BaseConverter(self):
    from testConvert import BaseConverterTest
    assert isinstance(self, BaseConverterTest)

Example 3 - “can_substitute”:

from liskov import can_substitute

@can_substitute('testCalc.BasicCalcTest', 'testConvert.BaseConverterTest')
class ScientificCalcTest(object):
  def test_it_is_a_subtype_of_BasicCalc(self):
    from testCalc import BasicCalcTest
    assert isinstance(self, BasicCalcTest)

  def test_it_is_a_subtype_of_BaseConverter(self):
    from testConvert import BaseConverterTest
    assert isinstance(self, BaseConverterTest)

Example 4 - Constraints:

This example follow Liskov and Wing constrained subtypes Elephants hierarchy example from “Behavioural Subtyping using invariants and constraints” (link above)

Elephants can be white, green or blue RoyalElephant is always blue AlbinoElephant is always white

Each instance of Elephant in ElephantTest is made with “new_elephant” ElephantTest test if an Elephant can be white, green or blue.

Declare Constraints with a decorator

from liskov import can_substitute, under_constraint
import elephant

@can_substitute('elephant.ElephantTest')
@under_constraint('test_it_can_be_grey', 'test_it_can_be_white')
class RoyalElephantTest(object):
  def new_elephant(self, *args):
    return elephant.RoyalElephant()

Declare Constraints with metaclass

Python 2 version

from liskov import behave_as
import elephant

class RoyalElephantTest(object):
  __metaclass__ = behave_as('elephant.ElephantTest').except_for('test_it_can_be_grey', 'test_it_can_be_white')
  def new_elephant(self, *args):
    return elephant.RoyalElephant()

Python 3 version

from liskov import behave_as
import elephant

metaclass = behave_as('elephant.ElephantTest').except_for('test_it_can_be_grey', 'test_it_can_be_white')
class RoyalElephantTest(object, metaclass=metaclass):
  def new_elephant(self, *args):
    return elephant.RoyalElephant()

Declare Constraints with subtype function

bind “subtype” to “constrain” with any of these operators: “& | + -”

from liskov import subtype, constrain
import elephant

ConstrainedElephantTest = lambda: subtype('elephant.ElephantTest') & constrain('test_it_can_be_grey', 'test_it_can_be_white')

class RoyalElephantTest(ConstrainedElephantTest()):
  def new_elephant(self, *args):
    return elephant.RoyalElephant()