import unittest
import warnings
import sys
import os
import re
from unittest.signals import registerResult

import eclipse.unittest as easeunit

class EASETestResult(unittest.result.TestResult):
    def __init__(self, stream, descriptions, verbosity):
        super(EASETestResult, self).__init__(stream, descriptions, verbosity)
        self.stream = stream
        self.showAll = verbosity > 1
        self.dots = verbosity == 1
        self.descriptions = descriptions
              
    def startTest(self, test):
        super(EASETestResult, self).startTest(test)
        easeunit.startTest(test._testMethodName, test.shortDescription())
       
    def stopTest(self, test):
        easeunit.endTest()
 
    def addError(self, test, err):
        try:
            if (hasattr(err[1], 'java_exception')):
                if ("org.eclipse.ease.lang.unittest.AssertionException" == err[1].java_exception.getClass().getName()):
                    self.addFailure(test, (AssertionError, AssertionError(err[1].java_exception.getMessage()), err[2]))
                    return
        except:
            pass

        super(EASETestResult, self).addError(test, err)
        self.addTestResult(org.eclipse.ease.lang.unittest.runtime.TestStatus.ERROR, str(err[0].__name__) + ": " + str(err[1]), self._convert_stacktrace(err[2]))
 
    def addFailure(self, test, err):
        super(EASETestResult, self).addFailure(test, err)
        self.addTestResult(org.eclipse.ease.lang.unittest.runtime.TestStatus.FAILURE, str(err[1]), self._convert_stacktrace(err[2]))
   
    def addTestResult(self, type, message, stacktrace=None):
        result = org.eclipse.ease.lang.unittest.runtime.IRuntimeFactory.eINSTANCE.createTestResult()
        result.setStatus(type);
        result.setMessage(message);
       
        try:
            if stacktrace:
                result.setStackTrace(stacktrace)
            else:
                result.setStackTrace(getScriptEngine().getStackTrace())
        except Exception:
            print("could not set stacktrace")
            pass
       
        easeunit.getTest().getResults().add(result);       
    
    def addSkip(self, test, reason):
        super(EASETestResult, self).addSkip(test, reason)
        self.addTestResult(org.eclipse.ease.lang.unittest.runtime.TestStatus.DISABLED, reason)
 
    def addUnexpectedSuccess(self, test):
        super(EASETestResult, self).addUnexpectedSuccess(test)
        self.addTestResult(org.eclipse.ease.lang.unittest.runtime.TestStatus.FAILURE, "We expected an error")

    def _convert_stacktrace(self, traceback):
        while traceback and self._is_relevant_tb_level(traceback):
            traceback = traceback.tb_next

        if not traceback:
            return None

        frame = traceback.tb_frame
        stacktrace = org.eclipse.ease.debugging.ScriptStackTrace()
        while frame:
            filename = frame.f_code.co_filename
            
            # Name mangled workspace file
            if re.match("^__ref_L/(.+)_[a-z]{10}$", filename):
                filename = filename[8:-11]
            
            # Simple workspace file
            elif filename.startswith("L/") and not os.path.exists(filename):
                filename = filename[2:]
            
            # Not a workspace file (so ignore)
            else:
                break
    
            # Convert to debug frame            
            path = org.eclipse.core.runtime.Path(filename)
            workspace = org.eclipse.core.resources.ResourcesPlugin.getWorkspace()
            file = workspace.getRoot().getFile(path)
            script = org.eclipse.ease.Script(filename, file, False)
            ease_frame = org.eclipse.ease.debugging.EaseDebugFrame(script, frame.f_lineno, 1, filename)
            stacktrace.add(ease_frame)
            
            # Check next entry in stacktrace
            frame = frame.f_back

        return stacktrace


class EASETestRunner(object):
    """A test runner class that cooperates with the Eclipse EASE framework.
    """
    resultclass = EASETestResult

    def __init__(self, stream=None, descriptions=True, verbosity=1,
                 failfast=False, buffer=False, resultclass=None, warnings=None):
        if stream is None:
            stream = sys.stderr
        
        self.stream = stream
        self.descriptions = descriptions
        self.verbosity = verbosity
        self.failfast = failfast
        self.buffer = buffer
        self.warnings = warnings
        if resultclass is not None:
            self.resultclass = resultclass

    def _makeResult(self):
        return self.resultclass(self.stream, self.descriptions, self.verbosity)

    def run(self, test):
        "Run the given test case or test suite."
        result = self._makeResult()
        registerResult(result)
        result.failfast = self.failfast
        result.buffer = self.buffer
        with warnings.catch_warnings():
            if self.warnings:
                # if self.warnings is set, use it to filter all the warnings
                warnings.simplefilter(self.warnings)
                # if the filter is 'default' or 'always', special-case the
                # warnings from the deprecated unittest methods to show them
                # no more than once per module, because they can be fairly
                # noisy.  The -Wd and -Wa flags can be used to bypass this
                # only when self.warnings is None.
                if self.warnings in ['default', 'always']:
                    warnings.filterwarnings('module',
                            category=DeprecationWarning,
                            message='Please use assert\w+ instead.')
            startTestRun = getattr(result, 'startTestRun', None)
            if startTestRun is not None:
                startTestRun()
            try:
                test(result)
            finally:
                stopTestRun = getattr(result, 'stopTestRun', None)
                if stopTestRun is not None:
                    stopTestRun()
        result.printErrors()
        run = result.testsRun

        expectedFails = unexpectedSuccesses = skipped = 0
        try:
            results = map(len, (result.expectedFailures,
                                result.unexpectedSuccesses,
                                result.skipped))
        except AttributeError:
            pass
        else:
            expectedFails, unexpectedSuccesses, skipped = results

        infos = []
        return result

if __name__ == "__ease_unittest__":
    # Dynamically create test suite to combine test cases
    tests = unittest.TestLoader().loadTestsFromModule(sys.modules["__main__"])
    testSuite = unittest.TestSuite(tests)
    
    runner = EASETestRunner()
    runner.run(testSuite)