import unittest 
import shutil
import inspect
from test import regrtest
import os
import sys
import tempfile

PSYCOPATH='..'

# ------ Regression Test -----
class PsycoProcessTestCase (unittest.TestCase):

    def __init__(self, test_filename, arg):
        unittest.TestCase.__init__ (self, 'test_process')
        self.test_filename = test_filename
        self.arg = arg or ''

    def get_signal(self, error):
        return error >> 8

    def get_exit_status (self,error):
        return error & 255
    def get_test_name(self):
        return self.test_filename
    def test_process (self):
        cwd = os.getcwd()
        outputlog = "stdout_%s.log" % self.get_test_name()
        errorlog = "error_%s.log" % self.get_test_name()
        #err = os.system ('"%s" %s %s 1>%s 2>%s'  % (sys.executable, self.test_filename, self.arg, outputlog, errorlog ))

        err = os.system ('"%s" %s %s'  % (sys.executable, self.test_filename, self.arg))

        if err != 0:
            self.error ('running %s child process returned'
                      '(signal %d), %d\n logs are in %s' % ( self.get_test_name(), 
                                                           self.get_signal(err),
                                                           self.get_exit_status(err), 
                                                           os.path.dirname(self.test_filename)))
        #if err != 0:
        #    self.fail('running %s child process returned'
        #              '(signal %d), %d\n logs are in %s' % ( self.get_test_name(), 
        #                                                   self.get_signal(err),
        #                                                   self.get_exit_status(err), 
        #                                                   os.path.dirname(self.test_filename)))

class PsycoTestEnvironTestCase(PsycoProcessTestCase):
    
    def __init__ (self, testenv, test_name):
        PsycoProcessTestCase.__init__(self,testenv.mainfile, test_name)
        self.test_name = test_name

    def get_test_name(self):
        return self.test_name

    def __str__(self):
        return "(%s)" % (self.test_name)

    def __repr__(self):
        return "<testMethod=%s>" % (self.test_name)

class PsycoTestEnvironmentBuilder(object):

    def __init__(self):
        # build a temp directory
        self.environ = tempfile.mkdtemp(prefix='psyco-test')
        self.fd,self.mainfile = tempfile.mkstemp(dir=self.environ)
        self.mainfile = os.path.join (self.environ, self.mainfile)

    def delete(self):
        shutil.rmtree(self.environ)

    def copy_psyco (self):
        shutil.copytree ('psyco', os.path.join(self.environ,'psyco'))

    def embed_script(self, script):
        fd = self.fd
        os.write (fd,script)
        os.close(fd)

def single_regression_test_logic ():
    import sys
    import psyco
    psyco.full()
    def confirm_still_in_psyco():
        return __in_psyco__
    from test import regrtest
    verbose = False
    ok = regrtest.runtest(sys.argv[1], 0, verbose=0, quiet=False)#, verbose2=True)
    assert confirm_still_in_psyco()
    sys.exit(ok)
    
### not used
def multi_regression_test_logic ():
    for i in range(repeat_counter):
        print '%s, Psyco iteration %d' % (test, i+1)
        ok = regrtest.runtest(test, 0, verbose, 0)
        if ok == 1:
            sys.exit(0)
        elif ok < 0:
            sys.exit(1)

class PsycoRegressionTestSuite (unittest.TestSuite):

    def __init__(self, tests):
        self.tests = tests

    def run(self, result, stream):
        peb = PsycoTestEnvironmentBuilder()
        peb.copy_psyco()
        peb.embed_script (inspect.getsource(single_regression_test_logic)+'\n\nsingle_regression_test_logic()')
        os.putenv ('PYTHONPATH',peb.environ)
        cwd = os.getcwd()
        for test in self.tests:
            if result.shouldStop:
                break
            os.chdir(peb.environ)
            #invoke a python process on the result
            stream.writeln('begin ' + str(test))
            PsycoTestEnvironTestCase(peb, test).__call__(result)
            stream.writeln('  end '  + str(test))
            os.chdir(cwd)
        if len(result.errors)==0 and len(result.failures)==0:
            peb.delete()
        return result

import time
from cStringIO import StringIO

class PsycoTextRunner(unittest.TextTestRunner):

    def run(self, test):
        "Run the given test case or test suite."
        result = self._makeResult()
        startTime = time.time()
        test(result, self.stream)
        stopTime = time.time()
        timeTaken = stopTime - startTime
        self.stream.writeln('')
        self.stream.writeln("FAILING TESTS")
        self.stream.writeln("-"*80)
        self.stream.writeln ("\n".join ( testenv.test_name for testenv,_ in result.failures ))
        self.stream.writeln('')
        self.stream.writeln("CHRASHING TESTS")
        self.stream.writeln("-"*80)
        self.stream.writeln ("\n".join ( testenv.test_name for testenv,_ in result.errors ))
        return result

if __name__ == '__main__':
    #normal
    suite = PsycoRegressionTestSuite (regrtest.findtests())
    runner = PsycoTextRunner()
    result = runner.run(suite)

    #XXX randomized