How to use the sciunit.Model function in sciunit

def test_get_model_state(self):
        from sciunit import Model
        
        m = Model()
        state = m.__getstate__()
        self.assertEqual(m.__dict__,state)

import sciunit
import SCU_Capabilities

class IonChannelModel(sciunit.Model, capabilities.Generates_IV_Curve,
        capabilities.Receives_Current, capabilities.Generates_Membrane_Potential):
        """A generic ion channel model."""

        def __init__(self, name=None, iv_curve=None, current=None, voltage=None):
            super(IonChannelModel, self).__init__(name=name)

        def generate_iv_curve(self):
            return self.iv_curve

        def receive_current(self):
            #Not clear what this should return
            pass

        def generate_membrane_potential(self):
            #Not clear what this should return
            pass

if self.score == True:
            return 'Pass'
        elif self.score == False:
            return 'Fail'
        else:
            return 'N/A'

# create a Capability
class ReturnsNumber(sciunit.Capability):
    """ This Model returns a real number. """

    def return_num(self):
        raise NotImplementedError("Must return a real number.")

# create a Model that has the above Capability
class RandomSample(sciunit.Model, ReturnsNumber):
    """ Generates a random number between 1 and 10. """

    def __init__(self):
        self.return_num()

    def return_num(self):
        return random.randint(1, 3)

# create a class of Test
class SingleNumberTest(sciunit.Test):
    """Tests that a single a single predicted number is equal to an observed one."""
    def __init__(self, observation=None, name=None):
        sciunit.Test.__init__(self, observation, name)

    required_capabilities = ReturnsNumber,

def test_error_types(self):
        from sciunit.errors import CapabilityError, BadParameterValueError,\
                                   PredictionError, InvalidScoreError
        from sciunit import Model, Capability

        CapabilityError(Model(),Capability)
        PredictionError(Model(),'foo')
        InvalidScoreError()
        BadParameterValueError('x',3)

def test_get_model_state(self):
        from sciunit import Model

        m = Model()
        state = m.__getstate__()
        self.assertEqual(m.__dict__, state)

def unimplemented(self, message=''):
        """Raise a `CapabilityNotImplementedError` with details."""
        from sciunit import Model
        capabilities = [obj for obj in self.__class__.mro() if issubclass(obj, Capability) and not issubclass(obj, Model)]
        model = self if isinstance(self, Model) else None
        capability = None if not capabilities else capabilities[0]
        print(model, capability)
        raise CapabilityNotImplementedError(model, capability, message)