def test_as_decorator(): '''Test `TempWorkingDirectorySetter` used as a decorator.''' with temp_file_tools.TemporaryFolder(prefix='temp_test_garlicsim_') \ as temp_folder: old_cwd = os.getcwd() @TempWorkingDirectorySetter(temp_folder) def f(): # Note that on Mac OS, the working dir will be phrased differently, # so we can't do `assert os.getcwd() == temp_folder`. Instead we'll # create a small file and check we can access it: with open('just_a_file', 'w') as my_file: my_file.write('One two three.') with open('just_a_file', 'r') as my_file: assert my_file.read() == 'One two three.' f() cute_testing.assert_polite_wrapper(f) with open(os.path.join(temp_folder, 'just_a_file'), 'r') as my_file: assert my_file.read() == 'One two three.' assert os.getcwd() == old_cwd
def test_cached_history_function(): def changes(history_browser): ''' Return how many cells changed between most recent state and its parent. ''' changes.called_flag = True try: state = history_browser[-1] last_state = history_browser[-2] except IndexError: return None board, last_board = state.board, last_state.board board_size = len(board._Board__list) counter = 0 for i in range(board_size): if board._Board__list[i] != last_board._Board__list[i]: counter += 1 return counter cached_changes = caching.history_cache(changes) cute_testing.assert_polite_wrapper(cached_changes, changes, same_signature=False) s = life.State.create_messy_root(5, 5) p = garlicsim.Project(life) r = p.root_this_state(s) leaf = p.simulate(r, 10) path = leaf.make_containing_path() result_1 = [cached_changes(node) for node in list(path)[0:5]] assert changes.called_flag is True changes.called_flag = False result_2 = [cached_changes(node) for node in list(path)[0:5]] assert changes.called_flag is False assert result_1 == result_2 result_1 = [cached_changes(node) for node in list(path)] assert changes.called_flag is True changes.called_flag = False result_2 = [cached_changes(node) for node in list(path)] assert changes.called_flag is False assert result_1 == result_2
def test_cached_history_function(): def changes(history_browser): ''' Return how many cells changed between most recent state and its parent. ''' changes.called_flag = True try: state = history_browser[-1] last_state = history_browser[-2] except IndexError: return None board, last_board = state.board, last_state.board board_size = len(board._Board__list) counter = 0 for i in xrange(board_size): if board._Board__list[i] != last_board._Board__list[i]: counter += 1 return counter cached_changes = caching.history_cache(changes) cute_testing.assert_polite_wrapper(cached_changes, changes, same_signature=False) s = life.State.create_messy_root(5, 5) p = garlicsim.Project(life) r = p.root_this_state(s) leaf = p.simulate(r, 10) path = leaf.make_containing_path() result_1 = [cached_changes(node) for node in list(path)[0:5]] assert changes.called_flag is True changes.called_flag = False result_2 = [cached_changes(node) for node in list(path)[0:5]] assert changes.called_flag is False assert result_1 == result_2 result_1 = [cached_changes(node) for node in list(path)] assert changes.called_flag is True changes.called_flag = False result_2 = [cached_changes(node) for node in list(path)] assert changes.called_flag is False assert result_1 == result_2
def test_polite_wrapper(): ''' Test that `profile_ready` decorator produces a polite function wrapper. e.g. that the name, documentation and signature of the original function are used in the wrapper function, and a few other things. ''' cute_testing.assert_polite_wrapper(cute_profile.profile_ready()(func), func)
def test_decorator(): '''Test using `RaiseAssertor` as a decorator.''' @RaiseAssertor(ZeroDivisionError) def f(): 1/0 f() cute_testing.assert_polite_wrapper(f)
def test_polite_wrapper(): ''' Test that `profile_ready` decorator produces a polite function wrapper. e.g. that the name, documentation and signature of the original function are used in the wrapper function, and a few other things. ''' cute_testing.assert_polite_wrapper( cute_profile.profile_ready()(func), func )
def test_as_decorator(): '''Test `TempRecursionLimitSetter` when used as a decorator.''' old_recursion_limit = sys.getrecursionlimit() @TempRecursionLimitSetter(1234) def f(): assert sys.getrecursionlimit() == 1234 assert sys.getrecursionlimit() == old_recursion_limit f() assert sys.getrecursionlimit() == old_recursion_limit cute_testing.assert_polite_wrapper(f)
def test_as_decorator(): '''Test `TempValueSetter` used as a decorator.''' def a(): pass a.x = 1 @TempValueSetter((a, 'x'), 2) def f(): assert a.x == 2 assert a.x == 1 f() assert a.x == 1 cute_testing.assert_polite_wrapper(f)
def test_api(): """Test the API of cached functions.""" f = cache()(counting_func) g = cache(max_size=3)(counting_func) for cached_function in (f, g): assert not hasattr(cached_function, "cache") cute_testing.assert_polite_wrapper(cached_function, counting_func) result_1 = cached_function(1) assert cached_function(1) == result_1 == cached_function(1) cached_function.cache_clear() result_2 = cached_function(1) assert cached_function(1) == result_2 == cached_function(1) assert result_1 != result_2 == cached_function(1) != result_1 # Asserting we're not using `dict.clear` or something: assert cached_function.cache_clear.__name__ == "cache_clear"
def test_api(): '''Test the API of cached functions.''' f = cache()(counting_func) g = cache(max_size=3)(counting_func) for cached_function in (f, g): assert not hasattr(cached_function, 'cache') cute_testing.assert_polite_wrapper(cached_function, counting_func) result_1 = cached_function(1) assert cached_function(1) == result_1 == cached_function(1) cached_function.cache_clear() result_2 = cached_function(1) assert cached_function(1) == result_2 == cached_function(1) assert result_1 != result_2 == cached_function(1) != result_1 # Asserting we're not using `dict.clear` or something: assert cached_function.cache_clear.__name__ == 'cache_clear'
def check_context_manager_type(context_manager_type, self_returning, error_catching): ''' Run checks on a context manager. `self_returning` is a flag saying whether the context manager's `__enter__` method returns itself. (For the `as` keyword after `with`.) `error_catching` says whether the context manager catches exceptions it gets and updates the `exception_type_caught` global. ''' global flag, exception_type_caught assert flag is None assert exception_type_caught is None ### Testing simple case: ################################################## # # with context_manager_type(7) as return_value: assert flag == 7 if self_returning: assert isinstance(return_value, context_manager_type) else: # self_returning is False assert return_value is None # # ### Finished testing simple case. ######################################### assert flag is None assert exception_type_caught is None ### Testing creating context manager before `with`: ####################### # # my_context_manager = context_manager_type(1.1) assert isinstance(my_context_manager, context_manager_type) with my_context_manager as return_value: assert flag == 1.1 if self_returning: assert return_value is my_context_manager else: # self_returning is False assert return_value is None # # ### Finished testing creating context manager before `with`. ############## assert flag is None assert exception_type_caught is None ### Testing decorated function: ########################################### # # @context_manager_type('meow') def f(): assert flag == 'meow' f() assert flag is None assert exception_type_caught is None # # ### Finished testing decorated function. ################################## ### Testing manually decorated function: ################################## # # def g(a, b=2, **kwargs): assert flag == 'meow' new_g = context_manager_type('meow')(g) with cute_testing.RaiseAssertor(AssertionError): g('whatever') assert flag is None assert exception_type_caught is None new_g('whatever') assert flag is None assert exception_type_caught is None cute_testing.assert_polite_wrapper(new_g, g) # # ### Finished testing manually decorated function. ######################### ### Testing deep nesting: ################################################# # # my_context_manager = context_manager_type(123) assert flag is None with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 assert flag == 123 assert flag == 123 assert flag == 123 assert flag == 123 assert flag is None with context_manager_type(1) as return_value_1: assert flag == 1 with context_manager_type(2) as return_value_2: assert flag == 2 with return_value_1 or context_manager_type(1): assert flag == 1 assert flag == 2 assert flag == 1 assert flag is None # # ### Finished testing deep nesting. ######################################## ########################################################################### ########################################################################### ### Now while raising exceptions: ### Testing simple case: ################################################## # # try: with context_manager_type(7) as return_value: assert flag == 7 if self_returning: assert isinstance(return_value, context_manager_type) else: # self_returning is False assert return_value is None raise TypeError('ooga booga') except Exception, exception: assert not error_catching assert type(exception) is TypeError
# # def g(a, b=2, **kwargs): assert flag == 'meow' eval('Ooga booga I am a syntax error.') with cute_testing.RaiseAssertor(AssertionError): g('whatever') assert flag is None assert exception_type_caught is None new_g = context_manager_type('meow')(g) assert flag is None assert exception_type_caught is None cute_testing.assert_polite_wrapper(new_g, g) try: new_g('whatever') except Exception, exception: assert not error_catching assert exception_type_caught is None assert type(exception) is SyntaxError else: assert error_catching assert exception_type_caught is SyntaxError exception_type_caught = None # # ### Finished testing manually decorated function. ######################## ### Testing deep nesting: #################################################
def check_context_manager_type(context_manager_type, self_returning, error_catching): ''' Run checks on a context manager. `self_returning` is a flag saying whether the context manager's `__enter__` method returns itself. (For the `as` keyword after `with`.) `error_catching` says whether the context manager catches exceptions it gets and updates the `exception_type_caught` global. ''' global flag, exception_type_caught assert flag is None assert exception_type_caught is None ### Testing simple case: ################################################## # # with context_manager_type(7) as return_value: assert flag == 7 if self_returning: assert isinstance(return_value, context_manager_type) else: # self_returning is False assert return_value is None # # ### Finished testing simple case. ######################################### assert flag is None assert exception_type_caught is None ### Testing creating context manager before `with`: ####################### # # my_context_manager = context_manager_type(1.1) assert isinstance(my_context_manager, context_manager_type) with my_context_manager as return_value: assert flag == 1.1 if self_returning: assert return_value is my_context_manager else: # self_returning is False assert return_value is None # # ### Finished testing creating context manager before `with`. ############## assert flag is None assert exception_type_caught is None ### Testing decorated function: ########################################### # # @context_manager_type('meow') def f(): assert flag == 'meow' f() assert flag is None assert exception_type_caught is None # # ### Finished testing decorated function. ################################## ### Testing manually decorated function: ################################## # # def g(a, b=2, **kwargs): assert flag == 'meow' new_g = context_manager_type('meow')(g) with cute_testing.RaiseAssertor(AssertionError): g('whatever') assert flag is None assert exception_type_caught is None new_g('whatever') assert flag is None assert exception_type_caught is None cute_testing.assert_polite_wrapper(new_g, g) # # ### Finished testing manually decorated function. ######################### ### Testing deep nesting: ################################################# # # my_context_manager = context_manager_type(123) assert flag is None with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 assert flag == 123 assert flag == 123 assert flag == 123 assert flag == 123 assert flag is None with context_manager_type(1) as return_value_1: assert flag == 1 with context_manager_type(2) as return_value_2: assert flag == 2 with return_value_1 or context_manager_type(1): assert flag == 1 assert flag == 2 assert flag == 1 assert flag is None # # ### Finished testing deep nesting. ######################################## ########################################################################### ########################################################################### ### Now while raising exceptions: ### Testing simple case: ################################################## # # try: with context_manager_type(7) as return_value: assert flag == 7 if self_returning: assert isinstance(return_value, context_manager_type) else: # self_returning is False assert return_value is None raise TypeError('ooga booga') except Exception as exception: assert not error_catching assert type(exception) is TypeError else: assert error_catching assert exception_type_caught is TypeError exception_type_caught = None # # ### Finished testing simple case. ######################################### assert flag is None ### Testing creating context manager before `with`: ####################### # # my_context_manager = context_manager_type(1.1) assert isinstance(my_context_manager, context_manager_type) try: with my_context_manager as return_value: assert flag == 1.1 if self_returning: assert return_value is my_context_manager else: # self_returning is False assert return_value is None {}[3] except Exception as exception: assert not error_catching assert exception_type_caught is None assert type(exception) is KeyError else: assert error_catching assert exception_type_caught is KeyError exception_type_caught = None # # ### Finished testing creating context manager before `with`. ############## assert flag is None assert exception_type_caught is None ### Testing decorated function: ########################################### # # @context_manager_type('meow') def f(): assert flag == 'meow' 1/0 try: f() except Exception as exception: assert not error_catching assert exception_type_caught is None assert type(exception) is ZeroDivisionError else: assert error_catching assert exception_type_caught is ZeroDivisionError exception_type_caught = None # # ### Finished testing decorated function. ################################## assert flag is None exception_type_caught = None ### Testing manually decorated function: ################################## # # def g(a, b=2, **kwargs): assert flag == 'meow' eval('Ooga booga I am a syntax error.') with cute_testing.RaiseAssertor(AssertionError): g('whatever') assert flag is None assert exception_type_caught is None new_g = context_manager_type('meow')(g) assert flag is None assert exception_type_caught is None cute_testing.assert_polite_wrapper(new_g, g) try: new_g('whatever') except Exception as exception: assert not error_catching assert exception_type_caught is None assert type(exception) is SyntaxError else: assert error_catching assert exception_type_caught is SyntaxError exception_type_caught = None # # ### Finished testing manually decorated function. ######################## ### Testing deep nesting: ################################################# # # my_context_manager = context_manager_type(123) assert flag is None try: with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 raise StopIteration assert flag == 123 assert flag == 123 assert flag == 123 assert flag == 123 except Exception as exception: assert not error_catching assert exception_type_caught is None assert type(exception) is StopIteration else: assert error_catching assert exception_type_caught is StopIteration exception_type_caught = None assert flag is None try: with context_manager_type(1) as return_value_1: assert flag == 1 with context_manager_type(2) as return_value_2: assert flag == 2 with return_value_1 or context_manager_type(1): assert flag == 1 raise NotImplementedError assert flag == 2 assert flag == 1 except Exception as exception: assert not error_catching assert exception_type_caught is None assert type(exception) is NotImplementedError else: assert error_catching assert exception_type_caught is NotImplementedError exception_type_caught = None assert flag is None # # ### Finished testing deep nesting. ########################################