Пример #1
0
    def remoteSetUp(self):
        debug("%s", self.uuid)
        gst.log("%s" % self.uuid)
        # local variables

        # create the pipeline
        try:
            self.pipeline = self.createPipeline()
        except:
            exception("Error while creating pipeline")
            self.pipeline = None
        finally:
            self.validateStep("valid-pipeline", not self.pipeline == None)
            if self.pipeline == None:
                self.remoteStop()
                return

        factory = self.pipeline.get_factory()
        if factory is None:
            facname = "(no factory)"
        else:
            facname = factory.get_name()
        self._elements = [(self.pipeline.get_name(),facname,
                           "")] #name,factoryname,parentname
        self._watchContainer(self.pipeline)

        # connect to bus
        self.bus = self.pipeline.get_bus()
        self.bus.add_signal_watch()
        self.bus.connect("message", self._busMessageHandlerCb)
        PythonDBusTest.remoteSetUp(self)
    def isExpectedResult(self, checkitem, result, extra_info):
        for pattern in self._expected_failure_patterns:

            if checkitem not in pattern["results"]:
                continue

            if str(result) not in pattern["results"][checkitem]:
                if "None" in pattern["results"][checkitem]:
                    debug("This rule only matches skipped checks.")
                elif "0" in pattern["results"][checkitem]:
                    debug("This rule only matches failed checks.")
                else:
                    warning("This rule doesn't match any checks: %s", pattern)
                continue

            if "arguments" in pattern:
                for k, v in pattern["arguments"].items():
                    if k not in self.arguments:
                        break
                    if self.arguments[k] not in v:
                        break
                else:
                    return True
            else:
                return True

        return False
    def addSubTest(self, testclass, arguments, monitors=None, position=-1,
            instance_name=None):
        """
        testclass : a testclass to run next, can be a Scenario
        arguments : dictionnary of arguments
        monitors : list of (Monitor, monitorargs) to run the test with
        position : the position to insert the test in (-1 for last)
        instance_name : a human-readable name for the test.

        This method can be called several times in a row at any moment.
        """
        if instance_name is None:
            instance_name = "%u.%s" % (len(self._subtest_names),
                                       testclass.__test_name__)
        # filter out unused arguments in arguments for non-scenarios
        if not issubclass(testclass, Scenario):
            args = {}
            for validkey in testclass.getFullArgumentList():
                if validkey in arguments.keys():
                    args[validkey] = arguments[validkey]
        else:
            args = copy(arguments)

        debug("Appending subtest %r args:%r", testclass, args)
        if position == -1:
            self._tests.append((testclass, args, monitors, instance_name))
        else:
            self._tests.insert(position,
                                (testclass, args, monitors, instance_name))
        self._subtest_names.append(instance_name)
Пример #4
0
    def remoteTearDown(self):
        if not PythonDBusTest.remoteTearDown(self):
            return False
        gst.log("Tearing Down")
        # unref pipeline and so forth
        if self._waitcb:
            gobject.source_remove(self._waitcb)
            self._waitcb = None
        if self.pipeline:
            self.pipeline.set_state(gst.STATE_NULL)
        self.validateStep("no-errors-seen", self._errors == [])
        if not self._errors == []:
            self.extraInfo("errors", self._errors)

        if not self._tags == {}:
            debug("Got tags %r", self._tags)
            for key, val in self._tags.iteritems():
                if isinstance(val, int):
                    # make sure that only values < 2**31 (MAX_INT32) are ints
                    # TODO : this is gonna screw up MASSIVELY with values > 2**63
                    if val >= 2**31:
                        self._tags[key] = long(val)
            # FIXME : if the value is a list, the dbus python bindings screw up
            #
            # For the time being we remove the values of type list, but this is REALLY
            # bad.
            listval = [x for x in self._tags.keys() if type(self._tags[x]) == list]
            if listval:
                warning("Removing this from the taglist since they're list:%r", listval)
                for val in listval:
                    del self._tags[val]
            self.extraInfo("tags", dbus.Dictionary(self._tags, signature="sv"))
        if not self._elements == []:
            self.extraInfo("elements-used", self._elements)
        return True
 def setStdOutAndErr(self, stderr_out_path):
     debug("New path: %s", stderr_out_path)
     self._stdout = stderr_out_path
     self._stderr = self._stdout
     self._ensureOutRedirection()
     if self._redir_tty_thread is not None:
         self._redir_tty_thread.setStdoutFile(stderr_out_path)
         self._redir_tty_thread.setStderrFile(stderr_out_path)
 def _generate(self):
     debug("Running generator command line in %r: %r" % (self.cwd, self.command))
     try:
         process = subprocess.Popen([self.command],
                                    stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                    cwd=self.cwd, shell=True, universal_newlines=True)
     except Exception, e:
         exception("Error running external generator: %r: %s", self.command, e)
         return []
Пример #7
0
 def _videoSourcePadAdded(self, videoSource, pad):
     debug("pad %r, videoCaps:%r", pad, self._videoCaps)
     try:
         if self._videoCaps:
             self._videoSource.link(self._videoEncoder, gst.Caps(str(self._videoCaps)))
         else:
             self._videoSource.link(self._videoEncoder)
     finally:
         debug("done")
Пример #8
0
 def _noMorePadsCb(self, dbin):
     debug("no more pads")
     gst.log("no more pads")
     if len([stream for stream in self._streams if not stream.raw]):
         debug("we have non-raw streams, stopping")
         # FIXME : add post-checking
         self._analyzeDecodebin()
         self._validateStreams()
         gobject.idle_add(self.stop)
    def callRemoteStart(self):
        # call remote instance "remoteStart()"
        if not self._remoteinstance:
            return

        self.args = self._parse_test_arguments(self.args)
        debug("Starting remote with argunents %s outputfiles %s", self.args, self.getOutputFiles())
        self._remoteinstance.remoteStart(self.args, self.getOutputFiles(),
                                         reply_handler=self._voidRemoteStartCallBackHandler,
                                         error_handler=self._voidRemoteStartErrBackHandler)
 def create_temp_filenames(self, global_files):
     oflist = self.getFullOutputFilesList()
     for ofname in oflist.iterkeys():
         if global_files == oflist[ofname]["global"]:
             if not ofname in self._outputfiles or not global_files:
                 ofd, opath = self._testrun.get_temp_file(nameid=ofname)
                 debug("created temp file name '%s' for outputfile '%s' [%s]",
                       opath, ofname, self.uuid)
                 self._outputfiles[ofname] = opath
                 os.close(ofd)
 def _findCoreFile(self):
     cwd = self.testrun.getWorkingDirectory()
     files = os.listdir(cwd)
     debug("files : %r", files)
     for fname in files:
         if fname == "core":
             return os.path.join(cwd, fname)
         if fname == "core.%d" % self.test._pid:
             return os.path.join(cwd, fname)
     return None
 def getIterationOutputFiles(self, iteration):
     """
     Return a dictionnary containing the outputfiles in the form of
     {outputfile-name: /path/to/file} for a specific iteration
     """
     try:
         return self._iteration_outputfiles[iteration]
     except KeyError:
         debug("No outputfile for iteration %s", iteration)
         return None
 def setTimeout(self, timeout):
     """
     Set the timeout period for running this test in seconds.
     Returns True if the timeout could be modified, else False.
     """
     debug("timeout : %d", timeout)
     if self._testtimeoutid:
         debug("updating timeout/timeouttime")
         self._testtimeouttime = self._testtimeouttime - self._timeout + timeout
     self._timeout = timeout
     return True
    def extraInfo(self, key, value):
        """
        Give extra information obtained while running the tests.

        If key was already given, the new value will override the value
        previously given for the same key.

        Called by the test itself
        """
        debug("%s : %r", key, value)
        self._extraInfo[key] = value
 def _testTimeoutCb(self):
     debug("timeout for %r", self)
     now = time.time()
     if now < self._testtimeouttime:
         debug("timeout must have changed in the meantime")
         diff = int((self._testtimeouttime - now) * 1000)
         self._testtimeoutid = gobject.timeout_add(diff, self._testTimeoutCb)
         return False
     self._testtimeoutid = 0
     self.stop()
     return False
 def stopAllThreads(self):
     debug("stopping all threads")
     joinedthreads = 0
     while(joinedthreads < len(self.threads)):
         for thread in self.threads:
             debug("Trying to stop thread %r" % thread)
             try:
                 thread.join()
                 joinedthreads += 1
             except:
                 warning("what happened ??")
 def addIterationOutputFile(self, key, value):
     """
     Report the location of an output file for a specific iteration
     """
     debug("%s : %s", key, value)
     try:
         self._iteration_outputfiles[self._iteration][key] = value
     except KeyError:
         kv = {}
         kv[key] = value
         self._iteration_outputfiles[self._iteration] = kv
Пример #18
0
 def tearDown(self):
     Monitor.tearDown(self)
     if self._logfile:
         os.close(self._logfile)
     if not os.path.getsize(self._logfilepath):
         # if log file is empty remove it
         debug("log file is empty, removing it")
         os.remove(self._logfilepath)
     else:
         # else report it
         self.setOutputFile("memcheck-log", self._logfilepath)
    def callRemoteSetUp(self):
        # call remote instance "remoteSetUp()"
        if not self._remoteinstance:
            return

        args = dict((k, v) for k, v in self.args.items() if (k in self.getFullArgumentList() and self.getFullArgumentList()[k]["global"] == True))
        args = self._parse_test_arguments(args)

        debug("Setting up remote with argunents %s outputfiles %s", args, self.getOutputFiles())
        self._remoteinstance.remoteSetUp(args, self.getOutputFiles(),
                                         reply_handler=self._voidRemoteSetUpCallBackHandler,
                                         error_handler=self._voidRemoteSetUpErrBackHandler)
 def setAsyncSetupTimeout(self, timeout):
     """
     Set the timeout period for asynchronous test to startup in
     seconds.
     Returns True if the timeout could be modified, else False.
     """
     debug("timeout : %d", timeout)
     if self._asynctimeoutid:
         debug("updating timeout/timeouttime")
         self._asynctimeouttime -= (self._asynctimeout - timeout)
     self._asynctimeout = timeout
     return True
    def quit(self):
        """
        Quit the client
        """
        debug("Quitting...")

        if self._running:
            self.stop()

        try:
            self._storage.close(self._exit)
        except:
            self._exit()
Пример #22
0
 def _elementAddedCb(self, container, element):
     debug("New element %r in container %r", element, container)
     factory = element.get_factory()
     factory_name = ""
     if not factory is None:
         factory_name = factory.get_name()
     # add himself
     self._elements.append((element.get_name(),
                            factory_name,
                            container.get_name()))
     # if bin, add current and connect signal
     if isinstance(element, gst.Bin):
         self._watchContainer(element)
 def tearDown(self):
     print 'Tearing down memcheck monitor'
     Monitor.tearDown(self)
     if self._logfile:
         os.close(self._logfile)
     if not os.path.getsize(self._logfilepath):
         # if log file is empty remove it
         debug("log file is empty, removing it")
         os.remove(self._logfilepath)
     else:
         # else report it
         print 'Reporting memcheck monitor log: ', self._logfilepath
         self.setOutputFile("memcheck-log", self._logfilepath)
Пример #24
0
 def remoteTest(self):
     # kickstart pipeline to initial state
     PythonDBusTest.remoteTest(self)
     debug("Setting pipeline to initial state %r", self.__pipeline_initial_state__)
     gst.log("Setting pipeline to initial state %r" % self.__pipeline_initial_state__)
     res = self.pipeline.set_state(self.__pipeline_initial_state__)
     debug("set_state returned %r", res)
     gst.log("set_state() returned %r" % res)
     self.validateStep("pipeline-change-state", not res == gst.STATE_CHANGE_FAILURE)
     if res == gst.STATE_CHANGE_FAILURE:
         warning("Setting pipeline to initial state failed, stopping test")
         gst.warning("State change failed, stopping")
         self.stop()
 def _initialize(self):
     # figure out the length of all generators
     debug("initializing")
     cpy = {}
     for key, value in self.generators.iteritems():
         gen, idx, nb = value
         nb = len(gen)
         if nb:
             self.combinations *= nb
         cpy[key] = [gen, idx, nb]
     debug("self.combinations: %d" % self.combinations)
     self.generators = cpy
     self._initialized = True
Пример #26
0
    def setWorkingDirectory(self, workdir):
        """
        Change the working directory. This can only be called when the
        TestRun isn't running.

        Returns True if the working directory was properly changed.
        Returns False if there was a problem.
        """
        if self._running:
            return False
        debug("Changing workdir to %s", workdir)
        self._workingdir = workdir
        self._outputdir = os.path.join(self._workingdir, "outputfiles")
        return True
    def _stop(self, paths):
        for desc, path in paths.iteritems():
            if not os.path.getsize(path):
                # if log file is empty remove it
                debug("log file is empty, removing it")
                os.remove(path)
            else:
                path = self._compressFile(path)
                self.addIterationOutputFile(desc, path)

        # Add global outputfiles
        for desc, path in self.getOutputFiles().iteritems():
            self.addIterationOutputFile(desc, self._compressFile(path, False))

        return True
    def addMonitor(self, monitor, monitorargs=None):
        """
        Add a monitor to this test instance.

        Checks will be done to ensure that the monitor can be applied
        on this instance.

        Returns True if the monitor was applied succesfully.
        """
        debug("monitor:%r, args:%r", monitor, monitorargs)
        # check if monitor is valid
        if not isinstance(self, monitor.__applies_on__):
            warning("The given monitor cannot be applied on this test")
            return False
        self._monitors.append((monitor, monitorargs))
def get_private_session_bus():
    """
    Get the private dbus BusConnection to use in the client.
    Tests should NOT use this method
    """
    global private_bus, private_bus_pid, private_bus_address
    if private_bus == None:
        if private_bus_pid:
            # cleanup
            kill_private_dbus()
        private_bus_address, private_bus_pid = spawn_session_dbus()[:2]
        debug("Creating BusConnection for address %s" % private_bus_address)
        gml = DBusGMainLoop()
        private_bus = BusConnection(private_bus_address, mainloop=gml)
    return private_bus
    def setUp(self):
        info("uuid:%s", self.uuid)
        if Test.setUp(self) == False:
            return False

        # get the remote launcher
        pargs = self._preargs
        pargs.extend(self.get_remote_launcher_args())
        shell = isinstance (pargs, basestring)

        cwd = self._testrun.getWorkingDirectory()

        self._environ["PRIVATE_DBUS_ADDRESS"] = self._bus_address
        info("Setting PRIVATE_DBUS_ADDRESS : %r" % self._bus_address)
        info("bus:%r" % self._bus)

        self._prepareArguments()

        if False: # useful to allow some time to run dbus-monitor on the private bus
            print("Setting PRIVATE_DBUS_ADDRESS : %r" % self._bus_address)
            time.sleep(5)

        # spawn the other process
        info("opening %r" % pargs)
        info("cwd %s" % cwd)
        try:
            self._subprocessspawntime = time.time()
            self._process = subprocess.Popen(pargs,
                                             stdin = self._stdin,
                                             stdout = subprocess.PIPE,
                                             stderr = subprocess.PIPE,
                                             env=self._environ,
                                             shell = shell,
                                             cwd=cwd)

            self._ensureOutRedirection()
            self._pid = self._process.pid
        except:
            exception("Error starting the subprocess command ! %r", pargs)
            self.validateChecklistItem("dbus-process-spawned", False)
            return False
        debug("Subprocess created successfully [pid:%d]", self._pid)

        self.validateChecklistItem("dbus-process-spawned")
        # add a poller for the proces
        self._processpollid = gobject.timeout_add(500, self._pollSubProcess)
        # Don't forget to set a timeout for waiting for the connection
        return True