Example #1
0
    def loadTestsFromNames(self, names, module=None):
        """Translate ids in the list of requested names into their
        test addresses, if they are found in my dict of tests.
        """
        log.debug('ltfn %s %s', names, module)
        try:
            fh = open(self.idfile, 'rb')
            data = load(fh)
            if 'ids' in data:
                self.ids = data['ids']
                self.failed = data['failed']
                self.source_names = data['source_names']
            else:
                # old ids field
                self.ids = data
                self.failed = []
                self.source_names = names
            if self.ids:
                self.id = max(self.ids) + 1
                self.tests = dict(list(zip(list(self.ids.values()), list(self.ids.keys()))))
            else:
                self.id = 1
            log.debug(
                'Loaded test ids %s tests %s failed %s sources %s from %s',
                self.ids, self.tests, self.failed, self.source_names,
                self.idfile)
            fh.close()
        except ValueError as e:
            # load() may throw a ValueError when reading the ids file, if it
            # was generated with a newer version of Python than we are currently
            # running.
            log.debug('Error loading %s : %s', self.idfile, str(e))
        except IOError:
            log.debug('IO error reading %s', self.idfile)

        if self.loopOnFailed and self.failed:
            self.collecting = False
            names = self.failed
            self.failed = []
        # I don't load any tests myself, only translate names like '#2'
        # into the associated test addresses
        translated = []
        new_source = []
        really_new = []
        for name in names:
            trans = self.tr(name)
            if trans != name:
                translated.append(trans)
            else:
                new_source.append(name)
        # names that are not ids and that are not in the current
        # list of source names go into the list for next time
        if new_source:
            new_set = set(new_source)
            old_set = set(self.source_names)
            log.debug("old: %s new: %s", old_set, new_set)
            really_new = [s for s in new_source
                          if not s in old_set]
            if really_new:
                # remember new sources
                self.source_names.extend(really_new)
            if not translated:
                # new set of source names, no translations
                # means "run the requested tests"
                names = new_source
        else:
            # no new names to translate and add to id set
            self.collecting = False
        log.debug("translated: %s new sources %s names %s",
                  translated, really_new, names)
        return (None, translated + really_new or names)
Example #2
0
     self.failed = []
 # I don't load any tests myself, only translate names like '#2'
 # into the associated test addresses
 translated = []
 new_source = []
 really_new = []
 for name in names:
     trans = self.tr(name)
     if trans != name:
         translated.append(trans)
     else:
         new_source.append(name)
 # names that are not ids and that are not in the current
 # list of source names go into the list for next time
 if new_source:
     new_set = set(new_source)
     old_set = set(self.source_names)
     log.debug("old: %s new: %s", old_set, new_set)
     really_new = [s for s in new_source
                   if not s in old_set]
     if really_new:
         # remember new sources
         self.source_names.extend(really_new)
     if not translated:
         # new set of source names, no translations
         # means "run the requested tests"
         names = new_source
 else:
     # no new names to translate and add to id set
     self.collecting = False
 log.debug("translated: %s new sources %s names %s",
Example #3
0
    def loadTestsFromNames(self, names, module=None):
        """Translate ids in the list of requested names into their
        test addresses, if they are found in my dict of tests.
        """
        log.debug("ltfn %s %s", names, module)
        try:
            fh = open(self.idfile, "r")
            data = load(fh)
            if "ids" in data:
                self.ids = data["ids"]
                self.failed = data["failed"]
                self.source_names = data["source_names"]
            else:
                # old ids field
                self.ids = data
                self.failed = []
                self.source_names = names
            if self.ids:
                self.id = max(self.ids) + 1
                self.tests = dict(zip(self.ids.values(), self.ids.keys()))
            else:
                self.id = 1
            log.debug(
                "Loaded test ids %s tests %s failed %s sources %s from %s",
                self.ids,
                self.tests,
                self.failed,
                self.source_names,
                self.idfile,
            )
            fh.close()
        except IOError:
            log.debug("IO error reading %s", self.idfile)

        if self.loopOnFailed and self.failed:
            self.collecting = False
            names = self.failed
            self.failed = []
        # I don't load any tests myself, only translate names like '#2'
        # into the associated test addresses
        translated = []
        new_source = []
        really_new = []
        for name in names:
            trans = self.tr(name)
            if trans != name:
                translated.append(trans)
            else:
                new_source.append(name)
        # names that are not ids and that are not in the current
        # list of source names go into the list for next time
        if new_source:
            new_set = set(new_source)
            old_set = set(self.source_names)
            log.debug("old: %s new: %s", old_set, new_set)
            really_new = [s for s in new_source if not s in old_set]
            if really_new:
                # remember new sources
                self.source_names.extend(really_new)
            if not translated:
                # new set of source names, no translations
                # means "run the requested tests"
                names = new_source
        else:
            # no new names to translate and add to id set
            self.collecting = False
        log.debug("translated: %s new sources %s names %s", translated, really_new, names)
        return (None, translated + really_new or names)
Example #4
0
     self.failed = []
 # I don't load any tests myself, only translate names like '#2'
 # into the associated test addresses
 translated = []
 new_source = []
 really_new = []
 for name in names:
     trans = self.tr(name)
     if trans != name:
         translated.append(trans)
     else:
         new_source.append(name)
 # names that are not ids and that are not in the current
 # list of source names go into the list for next time
 if new_source:
     new_set = set(new_source)
     old_set = set(self.source_names)
     log.debug("old: %s new: %s", old_set, new_set)
     really_new = [s for s in new_source if not s in old_set]
     if really_new:
         # remember new sources
         self.source_names.extend(really_new)
     if not translated:
         # new set of source names, no translations
         # means "run the requested tests"
         names = new_source
 else:
     # no new names to translate and add to id set
     self.collecting = False
 log.debug("translated: %s new sources %s names %s", translated,
           really_new, names)