randomtesting.py

from .basetesting import AbstractTester
import random
import logging

# Random tester.
class RandomTester(AbstractTester):

    def __init__(self, teacher, limit=1000, expectedLength=20, logger=None):
        # The tester will run test using the teacher
        self._teacher = teacher
        self._expectedLength = expectedLength
        self._limit = limit

        self._logger = logger or logging.getLogger(__name__)

    # Search a counterexample to teacher ioco model using at most limit actions
    # provide an expectedLength
    def findCounterexample(self, model):
        self._teacher.reset()
        model.reset()
        ce = ()
        i = 0
        # in case of multiple inputs in a row, I need to keep track of them
        consecutiveInputs = ()
        while i <= self._limit:
            #choice to reset or not:
            #(roll dice with expectedLength faces, if 0
            # I reset, otherwise I continue with one more input or output)
            reset = random.sample(range(self._expectedLength),1)[0]
            if reset != 0:
                # do not Reset
                typeAction = random.sample(set(['input', 'output']),1)[0]
                if typeAction == 'input':
                    # provide an input
                    # do not assume input enabledness
                    input = random.sample(model.inputs(),1)[0]
                    ce = ce + (input,)
                    model.move(input) # should be deterministic

                    # add input to consecutiveInputs
                    consecutiveInputs = consecutiveInputs + (input,)
                    # and continue with next step
                    # providing input costs an action
                    i += 1
                else:
                    # process consecutiveInputs and get an output
                    output = self._processInputs(consecutiveInputs)
                    consecutiveInputs = ()
                    if output not in model.outputs():
                        self._logger.info("Found a counterexample after "
                                          + str(i) + " input actions.")

                        self._teacher.reset()
                        model.reset()
                        # return counterexample trace and output obtained by
                        # testing
                        return ce, output
                    else:
                        model.move(output)
                        ce = ce + (output,)
                    # waiting for outputs does not cost actions
            else:
                # check if some inputs needed to be processed
                output = self._processInputs(consecutiveInputs)
                consecutiveInputs = ()
                if output not in model.outputs():
                    self._logger.info("Found a counterexample after "
                                      + str(i) + " input actions.")

                    self._teacher.reset()
                    model.reset()
                    # return counterexample trace and output obtained by
                    # testing
                    return ce, output
                # reset
                self._teacher.reset()
                model.reset()
                ce = ()
                # resetting costs a action
                i += 1


        # reached limit, check if some inputs needed still to be processed.
        if consecutiveInputs != ():
            # TODO: check if something is needed here
            output = self._processInputs(consecutiveInputs)

            # anyway reset the teacher
            self._teacher.reset()

            if output not in model.outputs():
                self._logger.info("Found a counterexample after "
                                  + str(i) + " input actions.")
                return ce, output

        return None, None

    def _processInputs(self, consecutiveInputs):
        if consecutiveInputs != ():
            output = self._teacher.oneOutput(consecutiveInputs)
            if output == None:
                # SUT did not accept an input. Reset everything and
                # continue
                # TODO: handle noninputenabledness of SUT here!
                return None
            return output
        return self._teacher.output()