DebugClients/Python3/DebugClientBase.py

branch
jsonrpc
changeset 5125
eb1b3e0577e4
parent 5124
1ba8ee313b57
child 5128
b6cbdba69967
--- a/DebugClients/Python3/DebugClientBase.py	Thu Sep 01 19:00:46 2016 +0200
+++ b/DebugClients/Python3/DebugClientBase.py	Thu Sep 01 20:03:50 2016 +0200
@@ -863,55 +863,55 @@
 ##                self.__generateFilterObjects(int(scope), filterString)
 ##                return
 ##            
-            if cmd == DebugProtocol.RequestUTPrepare:
-                fn, tn, tfn, failed, cov, covname, erase = arg.split('|')
-                sys.path.insert(0, os.path.dirname(os.path.abspath(fn)))
-                os.chdir(sys.path[0])
-                failed = eval(failed)
-
-                # set the system exception handling function to ensure, that
-                # we report on all unhandled exceptions
-                sys.excepthook = self.__unhandled_exception
-                self.__interceptSignals()
-                
-                try:
-                    import unittest
-                    utModule = imp.load_source(tn, fn)
-                    try:
-                        if failed:
-                            self.test = unittest.defaultTestLoader\
-                                .loadTestsFromNames(failed, utModule)
-                        else:
-                            self.test = unittest.defaultTestLoader\
-                                .loadTestsFromName(tfn, utModule)
-                    except AttributeError:
-                        self.test = unittest.defaultTestLoader\
-                            .loadTestsFromModule(utModule)
-                except Exception:
-                    exc_type, exc_value, exc_tb = sys.exc_info()
-                    self.write('{0}{1}\n'.format(
-                        DebugProtocol.ResponseUTPrepared,
-                        str((0, str(exc_type), str(exc_value)))))
-                    self.__exceptionRaised()
-                    return
-                
-                # generate a coverage object
-                if int(cov):
-                    from coverage import coverage
-                    self.cover = coverage(
-                        auto_data=True,
-                        data_file="{0}.coverage".format(
-                            os.path.splitext(covname)[0]))
-                    if int(erase):
-                        self.cover.erase()
-                else:
-                    self.cover = None
-                
-                self.write('{0}{1}\n'.format(
-                    DebugProtocol.ResponseUTPrepared,
-                    str((self.test.countTestCases(), "", ""))))
-                return
-            
+##            if cmd == DebugProtocol.RequestUTPrepare:
+##                fn, tn, tfn, failed, cov, covname, erase = arg.split('|')
+##                sys.path.insert(0, os.path.dirname(os.path.abspath(fn)))
+##                os.chdir(sys.path[0])
+##                failed = eval(failed)
+##
+##                # set the system exception handling function to ensure, that
+##                # we report on all unhandled exceptions
+##                sys.excepthook = self.__unhandled_exception
+##                self.__interceptSignals()
+##                
+##                try:
+##                    import unittest
+##                    utModule = imp.load_source(tn, fn)
+##                    try:
+##                        if failed:
+##                            self.test = unittest.defaultTestLoader\
+##                                .loadTestsFromNames(failed, utModule)
+##                        else:
+##                            self.test = unittest.defaultTestLoader\
+##                                .loadTestsFromName(tfn, utModule)
+##                    except AttributeError:
+##                        self.test = unittest.defaultTestLoader\
+##                            .loadTestsFromModule(utModule)
+##                except Exception:
+##                    exc_type, exc_value, exc_tb = sys.exc_info()
+##                    self.write('{0}{1}\n'.format(
+##                        DebugProtocol.ResponseUTPrepared,
+##                        str((0, str(exc_type), str(exc_value)))))
+##                    self.__exceptionRaised()
+##                    return
+##                
+##                # generate a coverage object
+##                if int(cov):
+##                    from coverage import coverage
+##                    self.cover = coverage(
+##                        auto_data=True,
+##                        data_file="{0}.coverage".format(
+##                            os.path.splitext(covname)[0]))
+##                    if int(erase):
+##                        self.cover.erase()
+##                else:
+##                    self.cover = None
+##                
+##                self.write('{0}{1}\n'.format(
+##                    DebugProtocol.ResponseUTPrepared,
+##                    str((self.test.countTestCases(), "", ""))))
+##                return
+##            
             if cmd == DebugProtocol.RequestUTRun:
                 from DCTestResult import DCTestResult
                 self.testResult = DCTestResult(self)
@@ -1489,6 +1489,67 @@
         if method == "RequestCompletion":
             self.__completionList(params["text"])
             return
+        
+        if method == "RequestUTPrepare":
+##            fn, tn, tfn, failed, cov, covname, erase = arg.split('|')
+##            sys.path.insert(0, os.path.dirname(os.path.abspath(fn)))
+##            os.chdir(sys.path[0])
+##            failed = eval(failed)
+##
+            # set the system exception handling function to ensure, that
+            # we report on all unhandled exceptions
+            sys.excepthook = self.__unhandled_exception
+            self.__interceptSignals()
+            
+            try:
+                import unittest
+                utModule = imp.load_source(
+                    params["testname"], params["filename"])
+                try:
+                    if params["failed"]:
+                        self.test = unittest.defaultTestLoader\
+                            .loadTestsFromNames(params["failed"], utModule)
+                    else:
+                        self.test = unittest.defaultTestLoader\
+                            .loadTestsFromName(params["testfunctionname"],
+                                               utModule)
+                except AttributeError:
+                    self.test = unittest.defaultTestLoader\
+                        .loadTestsFromModule(utModule)
+            except Exception:
+                exc_type, exc_value, exc_tb = sys.exc_info()
+##                self.write('{0}{1}\n'.format(
+##                    DebugProtocol.ResponseUTPrepared,
+##                    str((0, str(exc_type), str(exc_value)))))
+                self.__sendJsonCommand("ResponseUTPrepared", {
+                    "count": 0,
+                    "exception": exc_type.__name__,
+                    "message": str(exc_value),
+                })
+                self.__exceptionRaised()
+                return
+            
+            # generate a coverage object
+            if params["coverage"]:
+                from coverage import coverage
+                self.cover = coverage(
+                    auto_data=True,
+                    data_file="{0}.coverage".format(
+                        os.path.splitext(params["coveragefile"])[0]))
+                if params["coverageerase"]:
+                    self.cover.erase()
+            else:
+                self.cover = None
+            
+##            self.write('{0}{1}\n'.format(
+##                DebugProtocol.ResponseUTPrepared,
+##                str((self.test.countTestCases(), "", ""))))
+            self.__sendJsonCommand("ResponseUTPrepared", {
+                "count": self.test.countTestCases(),
+                "exception": "",
+                "message": "",
+            })
+            return
     
     def __sendJsonCommand(self, command, params):
         """

eric ide

mercurial