Пример #1
0
    def validate(self, monitor, snapshot, name, test):
        join, basename = os.path.join, os.path.basename
        desired_file = join(self._srcdir, basename(name))
        if not os.path.exists(desired_file):
            return 'no desired test structure'

        monitor.log.debug('validating structure of test %s' % name)
        try:
            desired = parser.load(desired_file)
        except:
            return 'desired test structure invalid'

        # look at the actual state
        actual = snapshot

        # check the state of the application
        if desired.alive != actual.alive:
            return 'alive: expected %r, received %r' \
                % (desired.alive, actual.alive)

        # sort the desired and actual uids (easier to compare them)
        key = operator.itemgetter('Uid')
        sort = lambda x: sorted(x, key = key)
        desired, actual = sort(desired.state), sort(actual.state)

        try:
            # validate children
            _compare_children(desired, actual)
            # validate properties based on desired structure
            self._compare_properties(desired, actual)
        except AssertionError, e:
            return 'assertion error: %s' % e
Пример #2
0
def load_state(monitor, efg_file):
    cache_file = '%s.cache' % efg_file
    if os.path.exists(cache_file):
        try:
            # reload cache file
            log.info('loading cache file from %s' % cache_file)
            return parser.load(cache_file)
        except Exception, e:
            log.exception(e)
Пример #3
0
def main(monitors, cfg):
    efg_file = cfg.get('general', 'efg_file')

    state, lock = load_state(monitors[0], efg_file), threading.Lock()

    config_loc = cfg.get('general', 'configuration')
    ignored_patterns = []
    try:
        ignored_patterns = parser.load(config_loc)
    except Exception, e:
        # Some error happened when reading the configuration file
        log.exception(e)
Пример #4
0
    def run(self):
        try:
            while True:
                interrupt_point()

                with self._lock:
                    testfile = self._testcases.pop()
                    left = len(self._testcases)
                log.info('running %s on monitor %s (%d left)' %
                         (testfile, self._monitor.name, left))
                test = parser.load(testfile)

                name = os.path.split(testfile)[1]
                logfile = os.path.join(
                    self._out_dir, os.path.splitext(name)[0]) + '.log'
                stdout = StringIO.StringIO()
                with self._monitor.open(logfile, stdout):
                    interrupt_point()

                    # Perform each action in the test
                    try:
                        for event in test:
                            event.perform(self._monitor)
                            time.sleep(self._steptime)
                            interrupt_point()

                        # Take final snapshot of the state and save it
                        snapshot = self._monitor.take_snapshot()
                        parser.dump(snapshot, os.path.join(
                                self._out_dir, name))
                    except Exception, e:
                        log.exception(e)
                        self._results.error(
                            testfile,
                            message = str(e),
                            stdout = stdout.getvalue())
                    else:
                        # Validate with oracles
                        for oracle in self._oracles:
                            reason = oracle.validate(
                                self._monitor, snapshot, testfile, test)
                            if reason:
                                log.error('test %s failed (oracle %s)' %
                                          (testfile, type(oracle)))
                                self._results.failure(
                                    testfile,
                                    message = '%s\nreason: %s' % (type(oracle), reason),
                                    stdout = stdout.getvalue())
                                break
                        else:
                            self._results.success(
                                testfile, stdout = stdout.getvalue())
Пример #5
0
def main(argv = None):
    cfg = guitarlib.initialize(argv)

    # Load in the efg file
    efg_file = cfg.get('general', 'efg_file')
    log.info('loading efg file %s' % efg_file)
    gr = parser.load(efg_file)

    try:
        pkg, class_ = cfg.get('testgenerator', 'plugin').rsplit('.', 1)
        testgenerator = getattr(__import__(pkg, fromlist=[class_]), class_)()
    except (ImportError, AttributeError), e:
        log.exception(e)
        return 1
Пример #6
0
 def preload(self, cfg):
     self._srcdir = cfg.get('replayer', 'desired')
     self._structure = parser.load(cfg.get('replayer', 'structure'))
     for name, expr in self._structure.iteritems():
         self._structure[name] = \
             compile(_expr_template % (expr, name), name, 'eval')