def test_execute(statements): executor = ThreadExecutor() loop = executor.event_loop for s, expected_state, expected_results in statements: statement = Statement(s, worksheet) statement._expected_state = expected_state statement._expected_results = expected_results statement._got_executing = False executor.add_statement(statement) def on_statement_executing(executor, statement): if hasattr(statement, '_got_state'): statement._out_of_order = True statement._got_executing = True def on_statement_complete(executor, statement): statement._got_state = statement.state statement._got_results = statement.results statement._out_of_order = False def on_complete(executor): loop.quit() def interrupt(): executor.interrupt() global timed_out timed_out = False def timeout(): global timed_out timed_out = True loop.quit() executor.sig_statement_executing.connect(on_statement_executing) executor.sig_statement_complete.connect(on_statement_complete) executor.sig_complete.connect(on_complete) if executor.compile(): executor.execute() interrupt_source = threading.Timer(0.5, interrupt) interrupt_source.start() timeout_source = threading.Timer(1.0, timeout) timeout_source.start() loop.run() if timed_out: raise AssertionError("Interrupting ThreadExecutor failed") interrupt_source.cancel() timeout_source.cancel() for s in executor.statements: assert_equals(s._got_state, s._expected_state) assert_equals(s._got_results, s._expected_results) if s._out_of_order: raise AssertionError("ThreadExecutor sent 'sig_statement_executing' after 'sig_statement_complete'") if s._expected_state == Statement.INTERRUPTED and not s._got_executing: raise AssertionError("ThreadExecutor did not send 'sig_statement_executing' within timeout")
def test_execute(statements): executor = ThreadExecutor() for s, expected_state, expected_results in statements: statement = Statement(s, worksheet) statement._expected_state = expected_state statement._expected_results = expected_results statement._got_executing = False executor.add_statement(statement) loop = gobject.MainLoop() def on_statement_executing(executor, statement): if hasattr(statement, '_got_state'): statement._out_of_order = True statement._got_executing = True def on_statement_complete(executor, statement): statement._got_state = statement.state statement._got_results = statement.results statement._out_of_order = False def on_complete(executor): loop.quit() def interrupt(): executor.interrupt() global timed_out timed_out = False def timeout(): global timed_out timed_out = True loop.quit() executor.connect('statement-executing', on_statement_executing) executor.connect('statement-complete', on_statement_complete) executor.connect('complete', on_complete) if executor.compile(): executor.execute() interrupt_source = gobject.timeout_add(500, interrupt) timeout_source = gobject.timeout_add(1000, timeout) loop.run() if timed_out: raise AssertionError("Interrupting ThreadExecutor failed") gobject.source_remove(interrupt_source) gobject.source_remove(timeout_source) for s in executor.statements: assert_equals(s._got_state, s._expected_state) assert_equals(s._got_results, s._expected_results) if s._out_of_order: raise AssertionError("ThreadExecutor sent 'statement-executing' after 'statement-complete'") if s._expected_state == Statement.INTERRUPTED and not s._got_executing: raise AssertionError("ThreadExecutor did not send 'statement-executing' within timeout")
def expect_result(text, result): s = Statement(text, worksheet) s.compile() s.execute() if s.error_message != None: raise Exception(s.error_message) if isinstance(result, basestring): assert_equals(s.results[0], result) else: assert_equals(s.results, result) pass pass
def do_test(import_text, evaluate_text, expected): nb = Notebook(base) scope = {} nb.setup_globals(scope) exec import_text in scope result = eval(evaluate_text, scope) assert_equals(result, expected) cleanup_pyc()
def expect_result(text, result): s = Statement(text, worksheet) s.compile() s.execute() if s.error_message != None : raise Exception(s.error_message) if isinstance(result, basestring): assert_equals(s.results[0], result) else: assert_equals(s.results, result) pass pass
def do_test(import_text, evaluate_text, expected, nb=None): if nb is None: nb = Notebook(base) scope = {} nb.setup_globals(scope) exec import_text in scope result = eval(evaluate_text, scope) assert_equals(result, expected) cleanup_pyc()
def test_execute(statements): executor = ThreadExecutor() for s, expected_state, expected_results in statements: statement = Statement(s, worksheet) statement._expected_state = expected_state statement._expected_results = expected_results executor.add_statement(statement) loop = gobject.MainLoop() def on_statement_complete(executor, statement): statement._got_state = statement.state statement._got_results = statement.results def on_complete(executor): loop.quit() def interrupt(): executor.interrupt() global timed_out timed_out = False def timeout(): global timed_out timed_out = True loop.quit() executor.connect('statement-complete', on_statement_complete) executor.connect('complete', on_complete) if executor.compile(): executor.execute() interrupt_source = gobject.timeout_add(500, interrupt) timeout_source = gobject.timeout_add(1000, timeout) loop.run() if timed_out: raise AssertionError("Interrupting ThreadExecutor failed") gobject.source_remove(interrupt_source) gobject.source_remove(timeout_source) for s in executor.statements: assert_equals(s._got_state, s._expected_state) assert_equals(s._got_results, s._expected_results)
def test_destroyable_0(): #-------------------------------------------------------------------------------------- from test_utils import adjust_environment, assert_equals adjust_environment() from reinteract.destroyable import Destroyable import gobject #-------------------------------------------------------------------------------------- class A(Destroyable, gobject.GObject): __gsignals__ = { 'changed': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()) } def do_a(*args): results.append('a') def do_b(*args): results.append('b') a = A() a.connect('changed', do_a) handler_id = a.connect('changed', do_b) a.disconnect(handler_id) results = [] a.emit('changed') assert_equals(results, ['a']) a.destroy() results = [] a.emit('changed') assert_equals(results, []) #-------------------------------------------------------------------------------------- pass
def test_reunicode_0(): #-------------------------------------------------------------------------------------- from test_utils import adjust_environment, assert_equals adjust_environment() from reinteract.reunicode import decode, escape_unsafe #-------------------------------------------------------------------------------------- def test_escape_unsafe(u, expected): assert_equals(escape_unsafe(u), expected) # Embedded NUL is \x00 test_escape_unsafe(u"a\x00b", u"a\\x00b") # Test a tab is left untouched test_escape_unsafe(u"\t", u"\t") # Non-BMP character (represented as surrogates for UCS-2 python) test_escape_unsafe(u"\U00010000", u"\\U00010000") # Unpaired surrogate test_escape_unsafe(u"\ud800", u"\\ud800") def test_decode_escaped(s, expected): assert_equals(decode(s, escape=True), expected) # Valid UTF-8 test_decode_escaped(u"\u1234".encode("utf8"), u"\u1234") # Invalid UTF-8 test_decode_escaped("abc\x80\x80abc", u"abc\\x80\\x80abc") # Mixture test_decode_escaped(u"\u1234".encode("utf8") + "\x80", u"\u1234\\x80") # embedded NUL test_decode_escaped("\x00", "\\x00") # Test a non-UTF-8 encoding assert_equals(decode("\xc0", encoding="ISO-8859-1"), u"\u00c0") #-------------------------------------------------------------------------------------- pass
def test_reunicode_0(): #-------------------------------------------------------------------------------------- from test_utils import adjust_environment, assert_equals adjust_environment() from reinteract.reunicode import decode, escape_unsafe #-------------------------------------------------------------------------------------- def test_escape_unsafe(u, expected): assert_equals(escape_unsafe(u), expected) # Embedded NUL is \x00 test_escape_unsafe(u"a\x00b", u"a\\x00b") # Test a tab is left untouched test_escape_unsafe(u"\t", u"\t") # Non-BMP character (represented as surrogates for UCS-2 python) test_escape_unsafe(u"\U00010000", u"\\U00010000") # Unpaired surrogate test_escape_unsafe(u"\ud800", u"\\ud800") def test_decode_escaped(s, expected): assert_equals(decode(s, escape=True), expected) # Valid UTF-8 test_decode_escaped(u"\u1234".encode("utf8"), u"\u1234") # Invalid UTF-8 test_decode_escaped("abc\x80\x80abc", u"abc\\x80\\x80abc") # Mixture test_decode_escaped(u"\u1234".encode("utf8") + "\x80", u"\u1234\\x80") # embedded NUL test_decode_escaped("\x00", "\\x00") # Test a non-UTF-8 encoding assert_equals(decode("\xc0", encoding="ISO-8859-1"), u"\u00c0") #-------------------------------------------------------------------------------------- pass
def test_destroyable_0(): #-------------------------------------------------------------------------------------- from test_utils import adjust_environment, assert_equals adjust_environment() from reinteract.destroyable import Destroyable import gobject #-------------------------------------------------------------------------------------- class A(Destroyable, gobject.GObject): __gsignals__ = { 'changed': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, ()) } def do_a(*args): results.append('a') def do_b(*args): results.append('b') a = A() a.connect('changed', do_a) handler_id = a.connect('changed', do_b) a.disconnect(handler_id) results = [] a.emit('changed') assert_equals(results, ['a']) a.destroy() results = [] a.emit('changed') assert_equals(results, []) #-------------------------------------------------------------------------------------- pass
def test_application_state_0(): #-------------------------------------------------------------------------------------- from test_utils import adjust_environment, assert_equals adjust_environment() from reinteract.application_state import ApplicationState, _section_name import tempfile, os #-------------------------------------------------------------------------------------- def test_section_name(path, expected): section_name = _section_name(path) assert_equals(section_name, expected) test_section_name('C:\foo', 'C:\foo') test_section_name('foo[]', 'foo%5b%5d') #-------------------------------------------------------------------------------------- f, location = tempfile.mkstemp(".state", "reinteract") os.close(f) try: nb_path = "C:\\Foo\\Bar" application_state = ApplicationState(location) application_state.notebook_opened(nb_path) nb_state = application_state.get_notebook_state(nb_path) nb_state.set_open_files([u"foo.rws", u"bar.rws"]) application_state.flush() application_state = ApplicationState(location) recent_notebooks = application_state.get_recent_notebooks() assert_equals(len(recent_notebooks), 1) assert_equals(recent_notebooks[0].path, nb_path) nb_state = application_state.get_notebook_state(nb_path) assert nb_state.get_last_opened() > 0 assert_equals(nb_state.get_open_files(), [u"foo.rws", u"bar.rws"]) finally: try: os.remove(location) except: pass pass #-------------------------------------------------------------------------------------- pass
if __name__ == '__main__': #pragma: no cover from test_utils import assert_equals def test_escape_unsafe(u, expected): assert_equals(escape_unsafe(u), expected) # Embedded NUL is \x00 test_escape_unsafe(u"a\x00b", u"a\\x00b") # Test a tab is left untouched test_escape_unsafe(u"\t", u"\t") # Non-BMP character (represented as surrogates for UCS-2 python) test_escape_unsafe(u"\U00010000", u"\\U00010000") # Unpaired surrogate test_escape_unsafe(u"\ud800", u"\\ud800") def test_decode_escaped(s, expected): assert_equals(decode(s, escape=True), expected) # Valid UTF-8 test_decode_escaped(u"\u1234".encode("utf8"), u"\u1234") # Invalid UTF-8 test_decode_escaped("abc\x80\x80abc", u"abc\\x80\\x80abc") # Mixture test_decode_escaped(u"\u1234".encode("utf8") + "\x80", u"\u1234\\x80") # embedded NUL test_decode_escaped("\x00", "\\x00") # Test a non-UTF-8 encoding assert_equals(decode("\xc0", encoding="ISO-8859-1"), u"\u00c0")
def test_escape_unsafe(u, expected): assert_equals(escape_unsafe(u), expected)
# Test import detection # def get_imports(code): rewriter = Rewriter(code) rewriter.rewrite_and_compile() return rewriter.get_imports() def test_imports(code, referenced): imports = get_imports(code) for module in referenced: if not imports.module_is_referenced(module): raise AssertionError("'%s': %s should be referenced and isn't", code, referenced) assert_equals(get_imports('a + 1'), None) test_imports('import re', ['re']) test_imports('import re as r', ['re']) test_imports('import re, os as o', ['re', 'os']) test_imports('from re import match', ['re']) test_imports('from re import match as m', ['re']) test_imports('from re import match as m, sub as s', ['re']) test_imports('from re import (match as m, sub as s)', ['re']) test_imports('from re import *', ['re']) assert_equals(get_imports('from __future__ import division').get_future_features(), set(['division'])) # # Test passing in future_features to use in compilation #
def test_quote_list(l, expected): quoted = _quote_list(l) assert_equals(quoted, expected) unquoted = _unquote_list(quoted) assert_equals(unquoted, l)
def test_execute(statements): executor = ThreadExecutor() loop = executor.event_loop for s, expected_state, expected_results in statements: statement = Statement(s, worksheet) statement._expected_state = expected_state statement._expected_results = expected_results statement._got_executing = False executor.add_statement(statement) def on_statement_executing(executor, statement): if hasattr(statement, '_got_state'): statement._out_of_order = True statement._got_executing = True def on_statement_complete(executor, statement): statement._got_state = statement.state statement._got_results = statement.results statement._out_of_order = False def on_complete(executor): loop.quit() def interrupt(): executor.interrupt() global timed_out timed_out = False def timeout(): global timed_out timed_out = True loop.quit() executor.sig_statement_executing.connect(on_statement_executing) executor.sig_statement_complete.connect(on_statement_complete) executor.sig_complete.connect(on_complete) if executor.compile(): executor.execute() interrupt_source = threading.Timer(0.5, interrupt) interrupt_source.start() timeout_source = threading.Timer(1.0, timeout) timeout_source.start() loop.run() if timed_out: raise AssertionError("Interrupting ThreadExecutor failed") interrupt_source.cancel() timeout_source.cancel() for s in executor.statements: assert_equals(s._got_state, s._expected_state) assert_equals(s._got_results, s._expected_results) if s._out_of_order: raise AssertionError( "ThreadExecutor sent 'sig_statement_executing' after 'sig_statement_complete'" ) if s._expected_state == Statement.INTERRUPTED and not s._got_executing: raise AssertionError( "ThreadExecutor did not send 'sig_statement_executing' within timeout" )
def test_quote_list(l, expected): quoted = _quote_list(l) assert_equals(quoted, expected) unquoted = _unquote_list(quoted) assert_equals(unquoted, l)
def test_section_name(path, expected): section_name = _section_name(path) assert_equals(section_name, expected)
def test_rewrite_0(): #-------------------------------------------------------------------------------------- from test_utils import adjust_environment, assert_equals adjust_environment() from reinteract.rewrite import Rewriter, UnsupportedSyntaxError import copy, re def rewrite_and_compile(code, output_func_name=None, future_features=None, print_func_name=None, encoding="utf8"): return Rewriter(code, encoding, future_features).rewrite_and_compile(output_func_name, print_func_name) # # Test that our intercepting of bare expressions to save the output works # def test_output(code, expected): compiled, _ = rewrite_and_compile(code, output_func_name='reinteract_output') test_args = [] def set_test_args(*args): test_args[:] = args class Builder: def __init__(self, arg=None): self.arg = arg def __enter__(self): return self.arg def __exit__(self, exception_type, exception_value, traceback): pass scope = { 'reinteract_output': set_test_args, '__reinteract_builder': Builder } exec compiled in scope if tuple(test_args) != tuple(expected): raise AssertionError("Got '%s', expected '%s'" % (test_args, expected)) test_output('a=3', ()) test_output('1', (1,)) test_output('1,2', (1,2)) test_output('1;2', (2,)) test_output('a=3; a', (3,)) test_output('def x():\n 1\ny = x()', ()) test_output('class X():\n 1\n pass\nx = X()', ()) # # Test our build "keyword" # test_output('build list() as l:\n l.append(1)', ([1],)) test_output('build list():\n pass', ([],)) test_output('build as l:\n l = 42', (42,)) test_output('build:\n pass', (None,)) # # Test that our intercepting of print works # def test_print(code, expected): compiled, _ = rewrite_and_compile(code, print_func_name='reinteract_print') test_args = [] def set_test_args(*args): test_args[:] = args scope = { 'reinteract_print': set_test_args } exec compiled in scope if tuple(test_args) != tuple(expected): raise AssertionError("Got '%s', expected '%s'" % (test_args, expected)) test_print('a=3', ()) test_print('print 1', (1,)) test_print('print 1,2', (1,2)) test_print('print "",', ("",)) test_print('for i in [0]: print i', (0,)) test_print('import sys; print >>sys.stderr, "",', ()) # # Test catching possible mutations of variables # def test_mutated(code, expected, prepare=None, assert_old=None, assert_new=None): compiled, mutated = rewrite_and_compile(code) # # Basic test - check the root and description for the returned list of mutations # mutated_root_desc = sorted(((root, description) for (root, description, _) in mutated)) # Extract the root from a description (just take the first word) def expand_root_desc(description): m = re.match(r"([a-zA-Z_0-9]+)", description) return m.group(1), description expected_root_desc = sorted((expand_root_desc(x) for x in expected)) if tuple(mutated_root_desc) != tuple(expected_root_desc): raise AssertionError("Got '%s', expected '%s'" % (mutated, expected)) # More complex test # # a) create old scope, execute 'prepare' in it # b) copy old scope, execute each copy statement # c) execute the code # c) run assertion checks in old and new scope if prepare: old_scope = { '__copy' : copy.copy } exec prepare in old_scope new_scope = dict(old_scope) for _, _, copy_code in mutated: exec copy_code in new_scope exec compiled in new_scope old_ok = eval(assert_old, old_scope) if not old_ok: raise AssertionError("Old scope assertion '%s' failed" % assert_old) new_ok = eval(assert_new, new_scope) if not new_ok: raise AssertionError("New scope assertion '%s' failed" % assert_new) test_mutated('a[0] = 1', ('a',), 'a = [2]', 'a[0] == 2', 'a[0] == 1') test_mutated('a[0], b[0] = 1, 2', ('a', 'b'), 'a,b = [2],[1]', 'a[0],b[0] == 2,1', 'a[0],b[0] == 1,2') test_mutated('a[0], _ = 1', ('a')) test_mutated('a[0], b[0] = c[0], d[0] = 1, 2', ('a', 'b', 'c', 'd')) test_mutated('a[0][1] = 1', ('a', 'a[...]'), 'a = [[0,2],1]', 'a[0][1] == 2', 'a[0][1] == 1') # This isn't fully right - in the new scope b should be [1], not [] test_mutated('a[0].append(1)', ('a', 'a[...]'), 'b = []; a = [b]', 'b == [] and a == [b]', 'b == [] and a == [[1]]') test_mutated('a += 1', ('a',)) test_mutated('a[0] += 1', ('a', 'a[...]')) prepare = """ class A: def __init__(self): self.b = 1 def addmul(self, x,y): self.b += x * y def get_a(self): return self.a pass a = A() a.a = A() """ test_mutated('a.b = 2', ('a',), prepare, 'a.b == 1', 'a.b == 2') test_mutated('a.b = 2', ('a',), prepare, 'a.b == 1', 'a.b == 2') test_mutated('a.a.b = 2', ('a','a.a'), prepare, 'a.a.b == 1', 'a.a.b == 2') test_mutated('a.a.b += 1', ('a','a.a','a.a.b'), prepare, 'a.a.b == 1', 'a.a.b == 2') test_mutated('a.addmul(1,2)', ('a',), prepare, 'a.b == 1', 'a.b == 3') test_mutated('a.a.addmul(1,2)', ('a', 'a.a'), prepare, 'a.a.b == 1', 'a.a.b == 3') # We exempt some methods as being most likely getters. test_mutated('a.get_a()', ()) test_mutated('a.hasA()', ()) test_mutated('a.isa()', ()) # These don't actually work properly since we don't know to copy a.a # So we just check the descriptions and not the execution # test_mutated('a.get_a().b = 2', ('a.get_a(...)',)) test_mutated('a.get_a().a.b = 2', ('a.get_a(...).a',)) # Tests of skipping mutations when the mutations are actually of # local variables test_mutated('def f(x):\n x[1] = 2\n', ()) test_mutated('def f(y):\n x = [1]\n x[1] = 2\n', ()) test_mutated('def f(x):\n def g(x):\n pass', ()) test_mutated('def f(x):\n import g', ()) test_mutated('def f(x):\n from m import g', ()) test_mutated('def f(x):\n from m import g as h\n h[2] = 3', ()) test_mutated('class X:\n x = [1]\n x[1] = 2\n', ()) test_mutated('def f(x):\n class C:\n pass', ()) test_mutated('def f((x,)):\n x[1] = 2\n', ()) test_mutated('def f(((x,),)):\n x[1] = 2\n', ()) # But these are global mutations test_mutated('class X:\n x[1] = 2\n', ('x')) test_mutated('class X:\n global x\n x[1] = 2\n x = [1]\n', ('x')) # Trying to mutate a global variable inside a function is an error def test_unsupported_syntax(code): caught_exception = False try: rewrite_and_compile(code) except UnsupportedSyntaxError, e: caught_exception = True assert_equals(caught_exception, True)
def test_escape_unsafe(u, expected): assert_equals(escape_unsafe(u), expected)
def test_quote(s, expected): quoted = _quote(s) assert_equals(quoted, expected) unquoted = _unquote(quoted) assert_equals(unquoted, s)
def test_decode_escaped(s, expected): assert_equals(decode(s, escape=True), expected)
write_file("package1/__init__.py", "__all__ = ['mod2']") write_file("package1/mod2.py", "b = 2") write_file("package2/__init__.py", "") write_file("package2/mod3.py", "import package1.mod2\nc = package1.mod2.b + 1") do_test("import mod1", "mod1.__file__", os.path.join(base, "mod1.py")) do_test("import mod1", "mod1.a", 1) do_test("import mod1 as m", "m.a", 1) do_test("from mod1 import a", "a", 1) do_test("from mod1 import a as a2", "a2", 1) do_test("import package1.mod2", "package1.mod2.b", 2) do_test("import package1.mod2 as m", "m.b", 2) do_test("from package1 import mod2", "mod2.b", 2) do_test("from package1 import *", "mod2.b", 2) # http://www.reinteract.org/trac/ticket/5 do_test("import package2.mod3", "package2.mod3.c", 3) nb = Notebook(base) assert_equals(nb.file_for_absolute_path(os.path.dirname(base)), None) assert_equals(nb.file_for_absolute_path(base), None) assert_equals(nb.file_for_absolute_path(os.path.join(base, "mod1.py")).path, "mod1.py") assert_equals(nb.file_for_absolute_path(os.path.join(base, "package1")), None) assert_equals(nb.file_for_absolute_path(os.path.join(base, "package1/")), None) assert_equals(nb.file_for_absolute_path(os.path.join(base, "package1/mod2.py")).path, "package1/mod2.py") finally: cleanup()
def test_statement_0(): from test_utils import assert_equals, adjust_environment adjust_environment() from reinteract.statement import Statement from reinteract.notebook import Notebook nb = Notebook() from reinteract.worksheet import Worksheet worksheet = Worksheet(nb) def expect_result(text, result): s = Statement(text, worksheet) s.compile() s.execute() if s.error_message != None : raise Exception(s.error_message) if isinstance(result, basestring): assert_equals(s.results[0], result) else: assert_equals(s.results, result) pass pass # A bare expression should give the repr of the expression expect_result("'a'", repr('a')) expect_result("1,2", repr((1,2))) # Print, on the other hand, gives the string form of the expression, with # one result object per output line expect_result("print 'a'", 'a') expect_result("print 'a', 'b'", ['a b']) expect_result("print 'a\\nb'", ['a','b']) # Test that we copy a variable before mutating it (when we can detect # the mutation) s1 = Statement("b = [0]", worksheet) s1.compile() s1.execute() s2 = Statement("b[0] = 1", worksheet, parent=s1) s2.compile() s2.execute() s3 = Statement("b[0]", worksheet, parent=s2) s3.compile() s3.execute() assert_equals(s3.results[0], "1") s2a = Statement("b[0]", worksheet, parent=s1) s2a.compile() s2a.execute() assert_equals(s2a.results[0], "0") # Test __reinteract_wrappers with an unrealistic example s1 = Statement("__reinteract_wrappers = [ lambda x: 2 ]", worksheet) s1.compile() s1.execute() s2 = Statement("1", worksheet, parent=s1) s2.compile() s2.execute() assert_equals(s2.results[0], "2") # Tests of catching errors s1 = Statement("b = ", worksheet) assert_equals(s1.compile(), False) assert s1.error_message is not None s1 = Statement("b", worksheet) assert_equals(s1.compile(), True) assert_equals(s1.execute(), False) assert s1.error_message is not None # Tests of 'from __future__ import...' s1 = Statement("from __future__ import division", worksheet) s1.compile() assert_equals(s1.future_features, ['division']) s2 = Statement("from __future__ import with_statement", worksheet, parent=s1) s2.compile() assert_equals(s2.future_features, ['division', 'with_statement']) s1 = Statement("import __future__", worksheet) # just a normal import assert_equals(s1.future_features, None) # Advanced use of "context manager" protocol expect_result('from reinteract.statement import Statement; Statement.get_current() != None', repr(True)) #-------------------------------------------------------------------------------------- pass
def test_decode_escaped(s, expected): assert_equals(decode(s, escape=True), expected)
def test_quote(s, expected): quoted = _quote(s) assert_equals(quoted, expected) unquoted = _unquote(quoted) assert_equals(unquoted, s)
# Test recovering from a runtime error during import nb = Notebook(base) write_file("mod5.py", "a = b") try: do_test("import mod5", "mod5.a", 1, nb=nb) except NameError, e: pass # the old and new files will have the same second-resolution timestamps cleanup_pyc() write_file("mod5.py", "a = 1") nb.reset_module_by_filename(os.path.join(base, "mod5.py")) do_test("import mod5", "mod5.a", 1, nb=nb) nb = Notebook(base) assert_equals(nb.file_for_absolute_path(os.path.dirname(base)), None) assert_equals(nb.file_for_absolute_path(base), None) assert_equals( nb.file_for_absolute_path(os.path.join(base, "mod1.py")).path, "mod1.py") assert_equals( nb.file_for_absolute_path(os.path.join(base, "package1")), None) assert_equals( nb.file_for_absolute_path(os.path.join(base, "package1/")), None) assert_equals( nb.file_for_absolute_path(os.path.join(base, "package1/mod2.py")).path, "package1/mod2.py") # Simple test of isolation - if this was the same notebook, then # we'd need to reset_module_by_filename()
def test_statement_0(): from test_utils import assert_equals, adjust_environment adjust_environment() from reinteract.statement import Statement from reinteract.notebook import Notebook nb = Notebook() from reinteract.worksheet import Worksheet worksheet = Worksheet(nb) def expect_result(text, result): s = Statement(text, worksheet) s.compile() s.execute() if s.error_message != None: raise Exception(s.error_message) if isinstance(result, basestring): assert_equals(s.results[0], result) else: assert_equals(s.results, result) pass pass # A bare expression should give the repr of the expression expect_result("'a'", repr('a')) expect_result("1,2", repr((1, 2))) # Print, on the other hand, gives the string form of the expression, with # one result object per output line expect_result("print 'a'", 'a') expect_result("print 'a', 'b'", ['a b']) expect_result("print 'a\\nb'", ['a', 'b']) # Test that we copy a variable before mutating it (when we can detect # the mutation) s1 = Statement("b = [0]", worksheet) s1.compile() s1.execute() s2 = Statement("b[0] = 1", worksheet, parent=s1) s2.compile() s2.execute() s3 = Statement("b[0]", worksheet, parent=s2) s3.compile() s3.execute() assert_equals(s3.results[0], "1") s2a = Statement("b[0]", worksheet, parent=s1) s2a.compile() s2a.execute() assert_equals(s2a.results[0], "0") # Test __reinteract_wrappers with an unrealistic example s1 = Statement("__reinteract_wrappers = [ lambda x: 2 ]", worksheet) s1.compile() s1.execute() s2 = Statement("1", worksheet, parent=s1) s2.compile() s2.execute() assert_equals(s2.results[0], "2") # Tests of catching errors s1 = Statement("b = ", worksheet) assert_equals(s1.compile(), False) assert s1.error_message is not None s1 = Statement("b", worksheet) assert_equals(s1.compile(), True) assert_equals(s1.execute(), False) assert s1.error_message is not None # Tests of 'from __future__ import...' s1 = Statement("from __future__ import division", worksheet) s1.compile() assert_equals(s1.future_features, ['division']) s2 = Statement("from __future__ import with_statement", worksheet, parent=s1) s2.compile() assert_equals(s2.future_features, ['division', 'with_statement']) s1 = Statement("import __future__", worksheet) # just a normal import assert_equals(s1.future_features, None) # Advanced use of "context manager" protocol expect_result( 'from reinteract.statement import Statement; Statement.get_current() != None', repr(True)) #-------------------------------------------------------------------------------------- pass
test_section_name('foo[]', 'foo%5b%5d') ###### f, location = tempfile.mkstemp(".state", "reinteract") os.close(f) try: nb_path = "C:\\Foo\\Bar" application_state = ApplicationState(location) application_state.notebook_opened(nb_path) nb_state = application_state.get_notebook_state(nb_path) nb_state.set_open_files(["foo.rws", "bar.rws"]) application_state.flush() application_state = ApplicationState(location) recent_notebooks = application_state.get_recent_notebooks() assert_equals(len(recent_notebooks), 1) assert_equals(recent_notebooks[0].path, nb_path) nb_state = application_state.get_notebook_state(nb_path) assert nb_state.get_last_opened() > 0 assert_equals(nb_state.get_open_files(), ["foo.rws", "bar.rws"]) finally: try: os.remove(location) except: pass