import trace
import unittest
import sys, os, tempfile

""" Implements a test suite based on unittest for the FunctionTracer
class implemented in trace.py."""

class TestClass:
    """ A simple test class used for the testing. """
    def __init__(self):
        pass
    def __del__(self):
        pass
    def test(self):
        print "TestClass test function."
    def test1(self, a):
        self.test ()
        print "TestClass test1 function", a

    def error(self):
        raise RuntimeError

class TestDerived(TestClass):
    """ A simple derived test class used for the testing. """
    def test1(self, a):
        self.test ()
        print "TestDerived test1 function", a
        TestClass.test1(self, a)
    

def _test_function():
    print "global test"
    a = TestClass()
    a.test1(1.01325)
    b = TestDerived()
    b.test1(1.01325)

def test_exception():
    a = TestClass()
    try:
        a.error()
    except RuntimeError:
        pass

def my_print(msg):
    sys.stdout.write(msg)
    sys.stdout.write("\n")    

class OutputEater:
    def __init__(self):
        self.msg = ""
    
    def eat(self, msg):
        self.msg = self.msg + msg + "\n"

class test_trace(unittest.TestCase):
    def check_trace_call(self):
        """Checking FunctionTracer.trace_call function."""
        t = trace.FunctionTracer()
        t.trace_call(_test_function, ())

    def check_start_stop(self):
        """Checking FunctionTracer.start and stop functions."""
        t = trace.FunctionTracer()
        t.start()
        _test_function()
        t.stop ()
        
        # now that tracing is stopped eat the output and check if
        # there are any messages.
        glutton = OutputEater()
        t.print_func = glutton.eat
        a = TestClass()
        a.test()
        assert glutton.msg == ""

    def check_verbosity(self):
        """Checking FunctionTracer verbosity settings."""
        t = trace.FunctionTracer()
        t.set_verbosity(0)
        t.trace_call(_test_function, ())
        t.set_verbosity(1)
        t.trace_call(_test_function, ())
        
    def check_indent(self):
        """Checking FunctionTracer indentation string setting."""
        t = trace.FunctionTracer()
        t.set_indent('|--')
        t.trace_call(_test_function, ())

    def check_long_filename(self):
        """Checking FunctionTracer long_filename setting."""
        t = trace.FunctionTracer()
        t.set_long_filename(0)
        t.trace_call(_test_function, ())
        t.set_long_filename(1)
        t.trace_call(_test_function, ())

    def check_file_info(self):
        "Checking FunctionTracer's file_info setting."
        # via constructor
        t = trace.FunctionTracer(file_info=0)
        t.trace_call(_test_function, ())
        t = trace.FunctionTracer(file_info=1)
        t.trace_call(_test_function, ())

        # via function call
        t = trace.FunctionTracer()
        t.set_file_info(0)
        t.trace_call(_test_function, ())
        
    def check_print_func(self):
        """Checking if FunctionTracer's print_func can be changed."""
        t = trace.FunctionTracer()
        t.print_func = my_print
        t.trace_call(_test_function, ())

    def check_output_filename(self):
        "Checking FunctionTracer's output_filename setting."
        # via constructor
        name = tempfile.mktemp()
        t = trace.FunctionTracer(output_filename=name)
        t.trace_call(_test_function, ())
        os.remove(name)

        # via function call
        name = tempfile.mktemp()
        t = trace.FunctionTracer()
        t.set_output_filename(name)
        t.trace_call(_test_function, ())
        os.remove(name)

    def check_dereference_args(self):
        "Checking FunctionTracer's dereference_args setting."
        # via constructor
        t = trace.FunctionTracer(dereference_args=1)
        t.trace_call(_test_function, ())

        # via function call
        t = trace.FunctionTracer()
        t.set_dereference_args(1)
        t.trace_call(_test_function, ())

    def check_exception(self):
        """Checking if exceptions are handled correctly."""
        t = trace.FunctionTracer()
        t.trace_call(test_exception, ())
        self.assertEquals(t.n_ind, 0)
        

def test_suite():
    suites = []
    suites.append(unittest.makeSuite(test_trace, 'check_'))
    total_suite = unittest.TestSuite(suites)
    return total_suite

def test():
    all_tests = test_suite()
    runner = unittest.TextTestRunner(verbosity=2)
    result = runner.run(all_tests)
    return result, runner

if __name__ == "__main__":
    test()