diff --git a/koans/about_asserts.py b/koans/about_asserts.py index d17ed0cdf..8c5945378 100644 --- a/koans/about_asserts.py +++ b/koans/about_asserts.py @@ -14,25 +14,25 @@ def test_assert_truth(self): # # http://bit.ly/about_asserts - self.assertTrue(False) # This should be True + self.assertTrue(True) # This should be True def test_assert_with_message(self): """ Enlightenment may be more easily achieved with appropriate messages. """ - self.assertTrue(False, "This should be True -- Please fix this") + self.assertTrue(True, "This should be True -- Please fix this") def test_fill_in_values(self): """ Sometimes we will ask you to fill in the values """ - self.assertEqual(__, 1 + 1) + self.assertEqual(2, 1 + 1) def test_assert_equality(self): """ To understand reality, we must compare our expectations against reality. """ - expected_value = __ + expected_value =2 actual_value = 1 + 1 self.assertTrue(expected_value == actual_value) @@ -40,7 +40,7 @@ def test_a_better_way_of_asserting_equality(self): """ Some ways of asserting equality are better than others. """ - expected_value = __ + expected_value =2 actual_value = 1 + 1 self.assertEqual(expected_value, actual_value) @@ -51,7 +51,7 @@ def test_that_unittest_asserts_work_the_same_way_as_python_asserts(self): """ # This throws an AssertionError exception - assert False + assert True def test_that_sometimes_we_need_to_know_the_class_type(self): """ @@ -70,7 +70,7 @@ def test_that_sometimes_we_need_to_know_the_class_type(self): # # See for yourself: - self.assertEqual(__, "navel".__class__) # It's str, not + self.assertEqual(str, "navel".__class__) # It's str, not # Need an illustration? More reading can be found here: # diff --git a/koans/about_attribute_access.py b/koans/about_attribute_access.py index f12f61143..4efc7af8c 100644 --- a/koans/about_attribute_access.py +++ b/koans/about_attribute_access.py @@ -15,12 +15,12 @@ class TypicalObject: def test_calling_undefined_functions_normally_results_in_errors(self): typical = self.TypicalObject() - with self.assertRaises(___): typical.foobar() + with self.assertRaises(AttributeError): typical.foobar() def test_calling_getattribute_causes_an_attribute_error(self): typical = self.TypicalObject() - with self.assertRaises(___): typical.__getattribute__('foobar') + with self.assertRaises(AttributeError): typical.__getattribute__('foobar') # THINK ABOUT IT: # @@ -36,19 +36,19 @@ def __getattribute__(self, attr_name): def test_all_attribute_reads_are_caught(self): catcher = self.CatchAllAttributeReads() - self.assertRegex(catcher.foobar, __) + self.assertRegex(catcher.foobar, "and it could not be found") def test_intercepting_return_values_can_disrupt_the_call_chain(self): catcher = self.CatchAllAttributeReads() - self.assertRegex(catcher.foobaz, __) # This is fine + self.assertRegex(catcher.foobaz, "and it could not be found") # This is fine try: catcher.foobaz(1) except TypeError as ex: err_msg = ex.args[0] - self.assertRegex(err_msg, __) + self.assertRegex(err_msg, "'str' object is not callable") # foobaz returns a string. What happens to the '(1)' part? # Try entering this into a python console to reproduce the issue: @@ -59,7 +59,7 @@ def test_intercepting_return_values_can_disrupt_the_call_chain(self): def test_changes_to_the_getattribute_implementation_affects_getattr_function(self): catcher = self.CatchAllAttributeReads() - self.assertRegex(getattr(catcher, 'any_attribute'), __) + self.assertRegex(getattr(catcher, 'any_attribute'), "and it could not be found") # ------------------------------------------------------------------ @@ -73,13 +73,13 @@ def __getattribute__(self, attr_name): def test_foo_attributes_are_caught(self): catcher = self.WellBehavedFooCatcher() - self.assertEqual(__, catcher.foo_bar) - self.assertEqual(__, catcher.foo_baz) + self.assertEqual("Foo to you too", catcher.foo_bar) + self.assertEqual("Foo to you too", catcher.foo_baz) def test_non_foo_messages_are_treated_normally(self): catcher = self.WellBehavedFooCatcher() - with self.assertRaises(___): catcher.normal_undefined_attribute + with self.assertRaises(AttributeError): catcher.normal_undefined_attribute # ------------------------------------------------------------------ @@ -114,7 +114,7 @@ def test_getattribute_is_a_bit_overzealous_sometimes(self): catcher = self.RecursiveCatcher() catcher.my_method() global stack_depth - self.assertEqual(__, stack_depth) + self.assertEqual(11, stack_depth) # ------------------------------------------------------------------ @@ -135,17 +135,17 @@ def test_getattr_ignores_known_attributes(self): catcher = self.MinimalCatcher() catcher.my_method() - self.assertEqual(__, catcher.no_of_getattr_calls) + self.assertEqual(0, catcher.no_of_getattr_calls) def test_getattr_only_catches_unknown_attributes(self): catcher = self.MinimalCatcher() catcher.purple_flamingos() catcher.free_pie() - self.assertEqual(__, + self.assertEqual("DuffObject", type(catcher.give_me_duff_or_give_me_death()).__name__) - self.assertEqual(__, catcher.no_of_getattr_calls) + self.assertEqual(3, catcher.no_of_getattr_calls) # ------------------------------------------------------------------ @@ -166,13 +166,13 @@ def test_setattr_intercepts_attribute_assignments(self): fanboy.comic = 'The Laminator, issue #1' fanboy.pie = 'blueberry' - self.assertEqual(__, fanboy.a_pie) + self.assertEqual("blueberry", fanboy.a_pie) # # NOTE: Change the prefix to make this next assert pass # - prefix = '__' + prefix = 'my' self.assertEqual("The Laminator, issue #1", getattr(fanboy, prefix + '_comic')) # ------------------------------------------------------------------ @@ -194,7 +194,7 @@ def test_it_modifies_external_attribute_as_expected(self): setter = self.ScarySetter() setter.e = "mc hammer" - self.assertEqual(__, setter.altered_e) + self.assertEqual("mc hammer", setter.altered_e) def test_it_mangles_some_internal_attributes(self): setter = self.ScarySetter() @@ -202,9 +202,9 @@ def test_it_mangles_some_internal_attributes(self): try: coconuts = setter.num_of_coconuts except AttributeError: - self.assertEqual(__, setter.altered_num_of_coconuts) + self.assertEqual(9, setter.altered_num_of_coconuts) def test_in_this_case_private_attributes_remain_unmangled(self): setter = self.ScarySetter() - self.assertEqual(__, setter._num_of_private_coconuts) + self.assertEqual(2, setter._num_of_private_coconuts) diff --git a/koans/about_class_attributes.py b/koans/about_class_attributes.py index 7a5be1df4..6b1987e12 100644 --- a/koans/about_class_attributes.py +++ b/koans/about_class_attributes.py @@ -13,36 +13,36 @@ class Dog: def test_objects_are_objects(self): fido = self.Dog() - self.assertEqual(__, isinstance(fido, object)) + self.assertEqual(True, isinstance(fido, object)) def test_classes_are_types(self): - self.assertEqual(__, self.Dog.__class__ == type) + self.assertEqual(True, self.Dog.__class__ == type) def test_classes_are_objects_too(self): - self.assertEqual(__, issubclass(self.Dog, object)) + self.assertEqual(True, issubclass(self.Dog, object)) def test_objects_have_methods(self): fido = self.Dog() - self.assertEqual(__, len(dir(fido))) + self.assertEqual(29, len(dir(fido))) def test_classes_have_methods(self): - self.assertEqual(__, len(dir(self.Dog))) + self.assertEqual(29, len(dir(self.Dog))) def test_creating_objects_without_defining_a_class(self): singularity = object() - self.assertEqual(__, len(dir(singularity))) + self.assertEqual(24, len(dir(singularity))) def test_defining_attributes_on_individual_objects(self): fido = self.Dog() fido.legs = 4 - self.assertEqual(__, fido.legs) + self.assertEqual(4, fido.legs) def test_defining_functions_on_individual_objects(self): fido = self.Dog() fido.wag = lambda : 'fidos wag' - self.assertEqual(__, fido.wag()) + self.assertEqual("fidos wag", fido.wag()) def test_other_objects_are_not_affected_by_these_singleton_functions(self): fido = self.Dog() @@ -52,7 +52,7 @@ def wag(): return 'fidos wag' fido.wag = wag - with self.assertRaises(___): rover.wag() + with self.assertRaises(AttributeError): rover.wag() # ------------------------------------------------------------------ @@ -75,19 +75,19 @@ def growl(cls): return "classmethod growl, arg: cls=" + cls.__name__ def test_since_classes_are_objects_you_can_define_singleton_methods_on_them_too(self): - self.assertRegex(self.Dog2.growl(), __) + self.assertRegex(self.Dog2.growl(), "classmethod growl") def test_classmethods_are_not_independent_of_instance_methods(self): fido = self.Dog2() - self.assertRegex(fido.growl(), __) - self.assertRegex(self.Dog2.growl(), __) + self.assertRegex(fido.growl(), "classmethod growl") + self.assertRegex(self.Dog2.growl(), "classmethod growl") def test_staticmethods_are_unbound_functions_housed_in_a_class(self): - self.assertRegex(self.Dog2.bark(), __) + self.assertRegex(self.Dog2.bark(), "staticmethod bark, arg: None") def test_staticmethods_also_overshadow_instance_methods(self): fido = self.Dog2() - self.assertRegex(fido.bark(), __) + self.assertRegex(fido.bark(), "staticmethod bark, arg: None") # ------------------------------------------------------------------ @@ -114,20 +114,20 @@ def set_name(cls, name): def test_classmethods_can_not_be_used_as_properties(self): fido = self.Dog3() - with self.assertRaises(___): fido.name = "Fido" + with self.assertRaises(TypeError): fido.name = "Fido" def test_classes_and_instances_do_not_share_instance_attributes(self): fido = self.Dog3() fido.set_name_from_instance("Fido") fido.set_name("Rover") - self.assertEqual(__, fido.get_name_from_instance()) - self.assertEqual(__, self.Dog3.get_name()) + self.assertEqual("Fido", fido.get_name_from_instance()) + self.assertEqual("Rover", self.Dog3.get_name()) def test_classes_and_instances_do_share_class_attributes(self): fido = self.Dog3() fido.set_name("Fido") - self.assertEqual(__, fido.get_name()) - self.assertEqual(__, self.Dog3.get_name()) + self.assertEqual("Fido", fido.get_name()) + self.assertEqual("Fido", self.Dog3.get_name()) # ------------------------------------------------------------------ @@ -142,13 +142,13 @@ def a_static_method(): a_static_method = staticmethod(a_static_method) def test_you_can_define_class_methods_without_using_a_decorator(self): - self.assertEqual(__, self.Dog4.a_class_method()) + self.assertEqual("dogs class method", self.Dog4.a_class_method()) def test_you_can_define_static_methods_without_using_a_decorator(self): - self.assertEqual(__, self.Dog4.a_static_method()) + self.assertEqual("dogs static method", self.Dog4.a_static_method()) # ------------------------------------------------------------------ def test_heres_an_easy_way_to_explicitly_call_class_methods_from_instance_methods(self): fido = self.Dog4() - self.assertEqual(__, fido.__class__.a_class_method()) + self.assertEqual("dogs class method", fido.__class__.a_class_method()) diff --git a/koans/about_classes.py b/koans/about_classes.py index 22dc4e7f0..04ee78357 100644 --- a/koans/about_classes.py +++ b/koans/about_classes.py @@ -12,10 +12,10 @@ def test_instances_of_classes_can_be_created_adding_parentheses(self): # NOTE: The .__name__ attribute will convert the class # into a string value. fido = self.Dog() - self.assertEqual(__, fido.__class__.__name__) + self.assertEqual("Dog", fido.__class__.__name__) def test_classes_have_docstrings(self): - self.assertRegex(self.Dog.__doc__, __) + self.assertRegex(self.Dog.__doc__, "Dogs need regular walkies. Never, ever let them drive.") # ------------------------------------------------------------------ @@ -28,12 +28,12 @@ def set_name(self, a_name): def test_init_method_is_the_constructor(self): dog = self.Dog2() - self.assertEqual(__, dog._name) + self.assertEqual("Paul", dog._name) def test_private_attributes_are_not_really_private(self): dog = self.Dog2() dog.set_name("Fido") - self.assertEqual(__, dog._name) + self.assertEqual("Fido", dog._name) # The _ prefix in _name implies private ownership, but nothing is truly # private in Python. @@ -41,11 +41,11 @@ def test_you_can_also_access_the_value_out_using_getattr_and_dict(self): fido = self.Dog2() fido.set_name("Fido") - self.assertEqual(__, getattr(fido, "_name")) + self.assertEqual("Fido", getattr(fido, "_name")) # getattr(), setattr() and delattr() are a way of accessing attributes # by method rather than through assignment operators - self.assertEqual(__, fido.__dict__["_name"]) + self.assertEqual("Fido", fido.__dict__["_name"]) # Yes, this works here, but don't rely on the __dict__ object! Some # class implementations use optimization which result in __dict__ not # showing everything. @@ -69,10 +69,10 @@ def test_that_name_can_be_read_as_a_property(self): fido.set_name("Fido") # access as method - self.assertEqual(__, fido.get_name()) + self.assertEqual("Fido", fido.get_name()) # access as property - self.assertEqual(__, fido.name) + self.assertEqual("Fido", fido.name) # ------------------------------------------------------------------ @@ -92,7 +92,7 @@ def test_creating_properties_with_decorators_is_slightly_easier(self): fido = self.Dog4() fido.name = "Fido" - self.assertEqual(__, fido.name) + self.assertEqual("Fido", fido.name) # ------------------------------------------------------------------ @@ -106,10 +106,10 @@ def name(self): def test_init_provides_initial_values_for_instance_variables(self): fido = self.Dog5("Fido") - self.assertEqual(__, fido.name) + self.assertEqual("Fido", fido.name) def test_args_must_match_init(self): - with self.assertRaises(___): + with self.assertRaises(TypeError): self.Dog5() # THINK ABOUT IT: @@ -119,7 +119,7 @@ def test_different_objects_have_different_instance_variables(self): fido = self.Dog5("Fido") rover = self.Dog5("Rover") - self.assertEqual(__, rover.name == fido.name) + self.assertEqual(False, rover.name == fido.name) # ------------------------------------------------------------------ @@ -131,10 +131,7 @@ def get_self(self): return self def __str__(self): - # - # Implement this! - # - return __ + return self._name def __repr__(self): return "" @@ -142,7 +139,7 @@ def __repr__(self): def test_inside_a_method_self_refers_to_the_containing_object(self): fido = self.Dog6("Fido") - self.assertEqual(__, fido.get_self()) # Not a string! + self.assertEqual(fido, fido.get_self()) # Not a string! def test_str_provides_a_string_version_of_the_object(self): fido = self.Dog6("Fido") @@ -152,17 +149,17 @@ def test_str_provides_a_string_version_of_the_object(self): def test_str_is_used_explicitly_in_string_interpolation(self): fido = self.Dog6("Fido") - self.assertEqual(__, "My dog is " + str(fido)) + self.assertEqual("My dog is Fido", "My dog is " + str(fido)) def test_repr_provides_a_more_complete_string_version(self): fido = self.Dog6("Fido") - self.assertEqual(__, repr(fido)) + self.assertEqual("", repr(fido)) def test_all_objects_support_str_and_repr(self): seq = [1, 2, 3] - self.assertEqual(__, str(seq)) - self.assertEqual(__, repr(seq)) + self.assertEqual('[1, 2, 3]', str(seq)) + self.assertEqual('[1, 2, 3]', repr(seq)) - self.assertEqual(__, str("STRING")) - self.assertEqual(__, repr("STRING")) + self.assertEqual('STRING', str("STRING")) + self.assertEqual("'STRING'", repr("STRING")) diff --git a/koans/about_comprehension.py b/koans/about_comprehension.py index e5add6d9e..662fb8a6d 100644 --- a/koans/about_comprehension.py +++ b/koans/about_comprehension.py @@ -13,8 +13,8 @@ def test_creating_lists_with_list_comprehensions(self): comprehension = [delicacy.capitalize() for delicacy in feast] - self.assertEqual(__, comprehension[0]) - self.assertEqual(__, comprehension[2]) + self.assertEqual("Lambs", comprehension[0]) + self.assertEqual("Orangutans", comprehension[2]) def test_filtering_lists_with_list_comprehensions(self): feast = ['spam', 'sloths', 'orangutans', 'breakfast cereals', @@ -22,15 +22,15 @@ def test_filtering_lists_with_list_comprehensions(self): comprehension = [delicacy for delicacy in feast if len(delicacy) > 6] - self.assertEqual(__, len(feast)) - self.assertEqual(__, len(comprehension)) + self.assertEqual(5, len(feast)) + self.assertEqual(3, len(comprehension)) def test_unpacking_tuples_in_list_comprehensions(self): list_of_tuples = [(1, 'lumberjack'), (2, 'inquisition'), (4, 'spam')] comprehension = [ skit * number for number, skit in list_of_tuples ] - self.assertEqual(__, comprehension[0]) - self.assertEqual(__, comprehension[2]) + self.assertEqual('lumberjack', comprehension[0]) + self.assertEqual('spamspamspamspam', comprehension[2]) def test_double_list_comprehension(self): list_of_eggs = ['poached egg', 'fried egg'] @@ -40,13 +40,13 @@ def test_double_list_comprehension(self): comprehension = [ '{0} and {1}'.format(egg, meat) for egg in list_of_eggs for meat in list_of_meats] - self.assertEqual(__, comprehension[0]) - self.assertEqual(__, len(comprehension)) + self.assertEqual('poached egg and lite spam', comprehension[0]) + self.assertEqual(6, len(comprehension)) def test_creating_a_set_with_set_comprehension(self): comprehension = { x for x in 'aabbbcccc'} - self.assertEqual(__, comprehension) # remember that set members are unique + self.assertEqual({'a', 'b', 'c'}, comprehension) # remember that set members are unique def test_creating_a_dictionary_with_dictionary_comprehension(self): dict_of_weapons = {'first': 'fear', 'second': 'surprise', @@ -55,7 +55,7 @@ def test_creating_a_dictionary_with_dictionary_comprehension(self): dict_comprehension = { k.upper(): weapon for k, weapon in dict_of_weapons.items() if weapon} - self.assertEqual(__, 'first' in dict_comprehension) - self.assertEqual(__, 'FIRST' in dict_comprehension) - self.assertEqual(__, len(dict_of_weapons)) - self.assertEqual(__, len(dict_comprehension)) + self.assertEqual(False, 'first' in dict_comprehension) + self.assertEqual(True, 'FIRST' in dict_comprehension) + self.assertEqual(5, len(dict_of_weapons)) + self.assertEqual(4, len(dict_comprehension)) diff --git a/koans/about_control_statements.py b/koans/about_control_statements.py index 842c8d91f..00da28b4f 100644 --- a/koans/about_control_statements.py +++ b/koans/about_control_statements.py @@ -10,13 +10,13 @@ def test_if_then_else_statements(self): result = 'true value' else: result = 'false value' - self.assertEqual(__, result) + self.assertEqual("true value", result) def test_if_then_statements(self): result = 'default value' if True: result = 'true value' - self.assertEqual(__, result) + self.assertEqual("true value", result) def test_if_then_elif_else_statements(self): if False: @@ -25,7 +25,7 @@ def test_if_then_elif_else_statements(self): result = 'true value' else: result = 'default value' - self.assertEqual(__, result) + self.assertEqual("true value", result) def test_while_statement(self): i = 1 @@ -33,7 +33,7 @@ def test_while_statement(self): while i <= 10: result = result * i i += 1 - self.assertEqual(__, result) + self.assertEqual(3628800, result) def test_break_statement(self): i = 1 @@ -42,7 +42,7 @@ def test_break_statement(self): if i > 10: break result = result * i i += 1 - self.assertEqual(__, result) + self.assertEqual(3628800, result) def test_continue_statement(self): i = 0 @@ -51,14 +51,14 @@ def test_continue_statement(self): i += 1 if (i % 2) == 0: continue result.append(i) - self.assertEqual(__, result) + self.assertEqual([1, 3, 5, 7, 9], result) def test_for_statement(self): phrase = ["fish", "and", "chips"] result = [] for item in phrase: result.append(item.upper()) - self.assertEqual([__, __, __], result) + self.assertEqual(["FISH", "AND", "CHIPS"], result) def test_for_statement_with_tuples(self): round_table = [ @@ -71,7 +71,7 @@ def test_for_statement_with_tuples(self): for knight, answer in round_table: result.append("Contestant: '" + knight + "' Answer: '" + answer + "'") - text = __ + text = "Green" self.assertRegex(result[2], text) diff --git a/koans/about_decorating_with_classes.py b/koans/about_decorating_with_classes.py index 00bd5fe90..b64e2f033 100644 --- a/koans/about_decorating_with_classes.py +++ b/koans/about_decorating_with_classes.py @@ -19,21 +19,21 @@ def test_partial_that_wrappers_no_args(self): """ max = functools.partial(self.maximum) - self.assertEqual(__, max(7,23)) - self.assertEqual(__, max(10,-10)) + self.assertEqual(23, max(7,23)) + self.assertEqual(10, max(10,-10)) def test_partial_that_wrappers_first_arg(self): max0 = functools.partial(self.maximum, 0) - self.assertEqual(__, max0(-4)) - self.assertEqual(__, max0(5)) + self.assertEqual(0, max0(-4)) + self.assertEqual(5, max0(5)) def test_partial_that_wrappers_all_args(self): always99 = functools.partial(self.maximum, 99, 20) always20 = functools.partial(self.maximum, 9, 20) - self.assertEqual(__, always99()) - self.assertEqual(__, always20()) + self.assertEqual(99, always99()) + self.assertEqual(20, always20()) # ------------------------------------------------------------------ @@ -64,8 +64,8 @@ def test_decorator_with_no_arguments(self): # To clarify: the decorator above the function has no arguments, even # if the decorated function does - self.assertEqual(__, self.foo()) - self.assertEqual(__, self.parrot('pieces of eight')) + self.assertEqual("foo, foo", self.foo()) + self.assertEqual("PIECES OF EIGHT, PIECES OF EIGHT", self.parrot('pieces of eight')) # ------------------------------------------------------------------ @@ -77,7 +77,7 @@ def test_what_a_decorator_is_doing_to_a_function(self): #wrap the function with the decorator self.sound_check = self.doubleit(self.sound_check) - self.assertEqual(__, self.sound_check()) + self.assertEqual("Testing..., Testing...", self.sound_check()) # ------------------------------------------------------------------ @@ -108,11 +108,11 @@ def idler(self, num): pass def test_decorator_with_an_argument(self): - self.assertEqual(__, self.count_badly(2)) - self.assertEqual(__, self.count_badly.__doc__) + self.assertEqual(5, self.count_badly(2)) + self.assertEqual("Increments a value by one. Kind of.", self.count_badly.__doc__) def test_documentor_which_already_has_a_docstring(self): - self.assertEqual(__, self.idler.__doc__) + self.assertEqual("Idler: Does nothing", self.idler.__doc__) # ------------------------------------------------------------------ @@ -123,6 +123,6 @@ def homer(self): return "D'oh" def test_we_can_chain_decorators(self): - self.assertEqual(__, self.homer()) - self.assertEqual(__, self.homer.__doc__) + self.assertEqual("D'oh, D'oh, D'oh, D'oh", self.homer()) + self.assertEqual("DOH!", self.homer.__doc__) diff --git a/koans/about_decorating_with_functions.py b/koans/about_decorating_with_functions.py index a51260213..15f6bcc9b 100644 --- a/koans/about_decorating_with_functions.py +++ b/koans/about_decorating_with_functions.py @@ -14,8 +14,8 @@ def mediocre_song(self): return "o/~ We all live in a broken submarine o/~" def test_decorators_can_modify_a_function(self): - self.assertRegex(self.mediocre_song(), __) - self.assertEqual(__, self.mediocre_song.wow_factor) + self.assertRegex(self.mediocre_song(), "We all live in a broken submarine") + self.assertEqual("COWBELL BABY!", self.mediocre_song.wow_factor) # ------------------------------------------------------------------ @@ -29,4 +29,4 @@ def render_tag(self, name): return name def test_decorators_can_change_a_function_output(self): - self.assertEqual(__, self.render_tag('llama')) + self.assertEqual("", self.render_tag('llama')) diff --git a/koans/about_deleting_objects.py b/koans/about_deleting_objects.py index 152265c98..3b3372baa 100644 --- a/koans/about_deleting_objects.py +++ b/koans/about_deleting_objects.py @@ -9,13 +9,13 @@ def test_del_can_remove_slices(self): del lottery_nums[1] del lottery_nums[2:4] - self.assertEqual(___, lottery_nums) + self.assertEqual([4, 15, 42], lottery_nums) def test_del_can_remove_entire_lists(self): lottery_nums = [4, 8, 15, 16, 23, 42] del lottery_nums - with self.assertRaises(___): win = lottery_nums + with self.assertRaises(UnboundLocalError): win = lottery_nums # ==================================================================== @@ -48,8 +48,8 @@ def test_del_can_remove_attributes(self): except AttributeError as e: err_msg2 = e.args[0] - self.assertRegex(err_msg1, __) - self.assertRegex(err_msg2, __) + self.assertRegex(err_msg1, "object has no attribute 'toilet_brushes'") + self.assertRegex(err_msg2, "object has no attribute 'hamsters'") # ==================================================================== @@ -78,7 +78,7 @@ def test_del_works_with_properties(self): self.assertEqual('Senor Ninguno', cowboy.name) del cowboy.name - self.assertEqual(__, cowboy.name) + self.assertEqual("The man with no name", cowboy.name) # ==================================================================== @@ -105,7 +105,7 @@ def test_another_way_to_make_a_deletable_property(self): self.assertEqual('Patrick', citizen.name) del citizen.name - self.assertEqual(__, citizen.name) + self.assertEqual("Number Six", citizen.name) # ==================================================================== @@ -119,6 +119,6 @@ def __delattr__(self, attr_name): def tests_del_can_be_overriden(self): sale = self.MoreOrganisedClosingSale() - self.assertEqual(__, sale.jellies()) + self.assertEqual(5, sale.jellies()) del sale.jellies - self.assertEqual(__, sale.last_deletion) + self.assertEqual('jellies', sale.last_deletion) diff --git a/koans/about_dice_project.py b/koans/about_dice_project.py index 27bc54a24..87f09d043 100644 --- a/koans/about_dice_project.py +++ b/koans/about_dice_project.py @@ -16,7 +16,14 @@ def values(self): def roll(self, n): # Needs implementing! # Tip: random.randint(min, max) can be used to generate random numbers - pass + if n < 1: + raise ValueError + + values = list() + for i in range(0, n): + values.append(random.randint(1, 6)) + + self._values = values class AboutDiceProject(Koan): def test_can_create_a_dice_set(self): diff --git a/koans/about_dictionaries.py b/koans/about_dictionaries.py index da1ed6bfe..0d81d1356 100644 --- a/koans/about_dictionaries.py +++ b/koans/about_dictionaries.py @@ -12,46 +12,46 @@ def test_creating_dictionaries(self): empty_dict = dict() self.assertEqual(dict, type(empty_dict)) self.assertDictEqual({}, empty_dict) - self.assertEqual(__, len(empty_dict)) + self.assertEqual(0, len(empty_dict)) def test_dictionary_literals(self): empty_dict = {} self.assertEqual(dict, type(empty_dict)) babel_fish = { 'one': 'uno', 'two': 'dos' } - self.assertEqual(__, len(babel_fish)) + self.assertEqual(2, len(babel_fish)) def test_accessing_dictionaries(self): babel_fish = { 'one': 'uno', 'two': 'dos' } - self.assertEqual(__, babel_fish['one']) - self.assertEqual(__, babel_fish['two']) + self.assertEqual('uno', babel_fish['one']) + self.assertEqual('dos', babel_fish['two']) def test_changing_dictionaries(self): babel_fish = { 'one': 'uno', 'two': 'dos' } babel_fish['one'] = 'eins' - expected = { 'two': 'dos', 'one': __ } + expected = { 'two': 'dos', 'one': 'eins' } self.assertDictEqual(expected, babel_fish) def test_dictionary_is_unordered(self): dict1 = { 'one': 'uno', 'two': 'dos' } dict2 = { 'two': 'dos', 'one': 'uno' } - self.assertEqual(__, dict1 == dict2) + self.assertEqual(True, dict1 == dict2) def test_dictionary_keys_and_values(self): babel_fish = {'one': 'uno', 'two': 'dos'} - self.assertEqual(__, len(babel_fish.keys())) - self.assertEqual(__, len(babel_fish.values())) - self.assertEqual(__, 'one' in babel_fish.keys()) - self.assertEqual(__, 'two' in babel_fish.values()) - self.assertEqual(__, 'uno' in babel_fish.keys()) - self.assertEqual(__, 'dos' in babel_fish.values()) + self.assertEqual(2, len(babel_fish.keys())) + self.assertEqual(2, len(babel_fish.values())) + self.assertEqual(True, 'one' in babel_fish.keys()) + self.assertEqual(False, 'two' in babel_fish.values()) + self.assertEqual(False, 'uno' in babel_fish.keys()) + self.assertEqual(True, 'dos' in babel_fish.values()) def test_making_a_dictionary_from_a_sequence_of_keys(self): cards = {}.fromkeys(('red warrior', 'green elf', 'blue valkyrie', 'yellow dwarf', 'confused looking zebra'), 42) - self.assertEqual(__, len(cards)) - self.assertEqual(__, cards['green elf']) - self.assertEqual(__, cards['yellow dwarf']) + self.assertEqual(5, len(cards)) + self.assertEqual(42, cards['green elf']) + self.assertEqual(42, cards['yellow dwarf']) diff --git a/koans/about_exceptions.py b/koans/about_exceptions.py index d321bbc50..b7e78d5e8 100644 --- a/koans/about_exceptions.py +++ b/koans/about_exceptions.py @@ -10,10 +10,10 @@ class MySpecialError(RuntimeError): def test_exceptions_inherit_from_exception(self): mro = self.MySpecialError.mro() - self.assertEqual(__, mro[1].__name__) - self.assertEqual(__, mro[2].__name__) - self.assertEqual(__, mro[3].__name__) - self.assertEqual(__, mro[4].__name__) + self.assertEqual("RuntimeError", mro[1].__name__) + self.assertEqual("Exception", mro[2].__name__) + self.assertEqual("BaseException", mro[3].__name__) + self.assertEqual("object", mro[4].__name__) def test_try_clause(self): result = None @@ -24,15 +24,15 @@ def test_try_clause(self): ex2 = ex - self.assertEqual(__, result) + self.assertEqual('exception handled', result) - self.assertEqual(__, isinstance(ex2, Exception)) - self.assertEqual(__, isinstance(ex2, RuntimeError)) + self.assertEqual(True, isinstance(ex2, Exception)) + self.assertEqual(False, isinstance(ex2, RuntimeError)) self.assertTrue(issubclass(RuntimeError, Exception), \ "RuntimeError is a subclass of Exception") - self.assertEqual(__, ex2.args[0]) + self.assertEqual("Oops", ex2.args[0]) def test_raising_a_specific_error(self): result = None @@ -42,8 +42,8 @@ def test_raising_a_specific_error(self): result = 'exception handled' msg = ex.args[0] - self.assertEqual(__, result) - self.assertEqual(__, msg) + self.assertEqual('exception handled', result) + self.assertEqual('My Message', msg) def test_else_clause(self): result = None @@ -55,7 +55,7 @@ def test_else_clause(self): else: result = 'no damage done' - self.assertEqual(__, result) + self.assertEqual('no damage done', result) def test_finally_clause(self): @@ -68,4 +68,4 @@ def test_finally_clause(self): finally: result = 'always run' - self.assertEqual(__, result) + self.assertEqual('always run', result) diff --git a/koans/about_extra_credit.py b/koans/about_extra_credit.py index cb5a67702..a75c1449f 100644 --- a/koans/about_extra_credit.py +++ b/koans/about_extra_credit.py @@ -10,10 +10,154 @@ # Write a player class and a Game class to complete the project. This # is a free form assignment, so approach it however you desire. +from functools import reduce from runner.koan import * +from .about_dice_project import DiceSet +from .about_scoring_project import score_plus + +class Player(): + def __init__(self, name): + self._name = name + self._score = 0 + self._ingame = False + + def __repr__(self): + return "{0}: {1} ({2})".format(self._name, self._score, "In the game" if self._ingame else "Not in the game") + + def name(self): + return self._name + + def score(self): + return self._score + + def take_turn(self): + print("{0} taking a turn...\n".format(self._name)) + dice = DiceSet() + + roll = True + non_scoring = 5 + running_total = 0 + while roll: + dice.roll(non_scoring) + result = dice.values + roll_score, non_scoring = score_plus(result) + print("Rolled {0}, score {1}\n".format(result, roll_score)) + + if roll_score == 0: + print("Rolled zero, out") + return self._score + + running_total += roll_score + if non_scoring == 0: + non_scoring = 5 + roll = self._should_reroll(running_total, non_scoring) + + if not self._ingame and running_total >= 300: + self._ingame = True + + if self._ingame: + self._score += running_total + + print("{0} Done.\n".format(self._name)) + return self._score + + def in_the_game(self): + return self._ingame + + def _should_reroll(self, running_total, dice_available): + if (dice_available >=4): + return True + else: + return running_total < 300 + +class Game(): + def __init__(self, player_count): + self._round = 0 + if (player_count < 2) or player_count > 10: + raise TypeError + + self._players = [] + for player_id in range(1, player_count + 1): + self._players.append(Player("Player {0}".format(player_id))) + + def __repr__(self): + output = "Game with {0} players. Round {1}.\n".format(len(self._players), self._round) + for player in self._players: + output += repr(player)+"\n" + return output + + def play(self): + keep_going = True + last_round = False + + while keep_going: + self._round += 1 + print(repr(self)) + + if last_round: + print ("It's the last round!") + keep_going = False + + for player in self._players: + player.take_turn() + if player.score() >= 3000: + last_round = True + + winner = reduce(lambda acc, p: p if p.score() > acc.score() else acc, self._players, self._players[0]) + print ("The winner is {0} with {1} points!".format(winner.name(), winner.score())) + class AboutExtraCredit(Koan): # Write tests here. If you need extra test classes add them to the # test suite in runner/path_to_enlightenment.py - def test_extra_credit_task(self): - pass + + def test_player_init(self): + player = Player("Adam") + self.assertEqual("Adam", player.name()) + self.assertEqual(0, player.score()) + + def test_player_should_reroll(self): + player = Player("Adam") + self.assertTrue(player._should_reroll(0, 5)) + self.assertTrue(player._should_reroll(1000, 5)) + self.assertFalse(player._should_reroll(1000, 1)) + self.assertFalse(player._should_reroll(1000, 3)) + self.assertTrue(player._should_reroll(100, 3)) + + def test_player_rep(self): + player1 = Player("Adam") + player2 = Player("Bob") + + player1._score = 100 + player2._score = 500 + + player2._ingame = True + + self.assertEqual("Adam: 100 (Not in the game)", repr(player1)) + self.assertEqual("Bob: 500 (In the game)", repr(player2)) + + def test_game_init(self): + game = Game(3) + self.assertEqual(3, len(game._players)) + self.assertEqual(0, game._round) + + with self.assertRaises(TypeError): + Game(1) + + with self.assertRaises(TypeError): + Game(-1) + + with self.assertRaises(TypeError): + Game(15) + + def test_game_rep(self): + game = Game(3) + self.assertEqual("Game with 3 players. Round 0.\n{0}\n{1}\n{2}\n".format(repr(game._players[0]), repr(game._players[1]), repr(game._players[2])), repr(game)) + + def test_take_turn(self): + player = Player("Adam") + player.take_turn() + + def test_play(self): + game = Game(3) + game.play() diff --git a/koans/about_generators.py b/koans/about_generators.py index a81a43ba6..ec2279309 100644 --- a/koans/about_generators.py +++ b/koans/about_generators.py @@ -19,7 +19,7 @@ def test_generating_values_on_the_fly(self): for bacon in bacon_generator: result.append(bacon) - self.assertEqual(__, result) + self.assertEqual(["crunchy bacon", "veggie bacon", "danish bacon"], result) def test_generators_are_different_to_list_comprehensions(self): num_list = [x*2 for x in range(1,3)] @@ -28,9 +28,9 @@ def test_generators_are_different_to_list_comprehensions(self): self.assertEqual(2, num_list[0]) # A generator has to be iterated through. - with self.assertRaises(___): num = num_generator[0] + with self.assertRaises(TypeError): num = num_generator[0] - self.assertEqual(__, list(num_generator)[0]) + self.assertEqual(2, list(num_generator)[0]) # Both list comprehensions and generators can be iterated though. However, a generator # function is only called on the first iteration. The values are generated on the fly @@ -44,8 +44,8 @@ def test_generator_expressions_are_a_one_shot_deal(self): attempt1 = list(dynamite) attempt2 = list(dynamite) - self.assertEqual(__, attempt1) - self.assertEqual(__, attempt2) + self.assertEqual(["Boom!", "Boom!", "Boom!"], attempt1) + self.assertEqual([], attempt2) # ------------------------------------------------------------------ @@ -59,12 +59,12 @@ def test_generator_method_will_yield_values_during_iteration(self): result = list() for item in self.simple_generator_method(): result.append(item) - self.assertEqual(__, result) + self.assertEqual(["peanut", "butter", "and", "jelly"], result) def test_generators_can_be_manually_iterated_and_closed(self): result = self.simple_generator_method() - self.assertEqual(__, next(result)) - self.assertEqual(__, next(result)) + self.assertEqual("peanut", next(result)) + self.assertEqual("butter", next(result)) result.close() # ------------------------------------------------------------------ @@ -75,7 +75,7 @@ def square_me(self, seq): def test_generator_method_with_parameter(self): result = self.square_me(range(2,5)) - self.assertEqual(__, list(result)) + self.assertEqual([4, 9, 16], list(result)) # ------------------------------------------------------------------ @@ -88,7 +88,7 @@ def sum_it(self, seq): def test_generator_keeps_track_of_local_variables(self): result = self.sum_it(range(2,5)) - self.assertEqual(__, list(result)) + self.assertEqual([2, 5, 9], list(result)) # ------------------------------------------------------------------ @@ -106,7 +106,7 @@ def test_generators_can_act_as_coroutines(self): # section of http://www.python.org/dev/peps/pep-0342/ next(generator) - self.assertEqual(__, generator.send(1 + 2)) + self.assertEqual(3, generator.send(1 + 2)) def test_before_sending_a_value_to_a_generator_next_must_be_called(self): generator = self.coroutine() @@ -114,7 +114,7 @@ def test_before_sending_a_value_to_a_generator_next_must_be_called(self): try: generator.send(1 + 2) except TypeError as ex: - self.assertRegex(ex.args[0], __) + self.assertRegex(ex.args[0], "can't send non-None value to a just-started generator") # ------------------------------------------------------------------ @@ -132,11 +132,11 @@ def test_generators_can_see_if_they_have_been_called_with_a_value(self): generator2 = self.yield_tester() next(generator2) - self.assertEqual(__, next(generator2)) + self.assertEqual('no value', next(generator2)) def test_send_none_is_equivalent_to_next(self): generator = self.yield_tester() next(generator) # 'next(generator)' is exactly equivalent to 'generator.send(None)' - self.assertEqual(__, generator.send(None)) + self.assertEqual('no value', generator.send(None)) diff --git a/koans/about_inheritance.py b/koans/about_inheritance.py index 5d2407dfa..3e8489425 100644 --- a/koans/about_inheritance.py +++ b/koans/about_inheritance.py @@ -23,31 +23,31 @@ def bark(self): return "yip" def test_subclasses_have_the_parent_as_an_ancestor(self): - self.assertEqual(__, issubclass(self.Chihuahua, self.Dog)) + self.assertEqual(True, issubclass(self.Chihuahua, self.Dog)) def test_all_classes_in_python_3_ultimately_inherit_from_object_class(self): - self.assertEqual(__, issubclass(self.Chihuahua, object)) + self.assertEqual(True, issubclass(self.Chihuahua, object)) # Note: This isn't the case in Python 2. In that version you have # to inherit from a built in class or object explicitly def test_instances_inherit_behavior_from_parent_class(self): chico = self.Chihuahua("Chico") - self.assertEqual(__, chico.name) + self.assertEqual("Chico", chico.name) def test_subclasses_add_new_behavior(self): chico = self.Chihuahua("Chico") - self.assertEqual(__, chico.wag()) + self.assertEqual("happy", chico.wag()) fido = self.Dog("Fido") - with self.assertRaises(___): fido.wag() + with self.assertRaises(AttributeError): fido.wag() def test_subclasses_can_modify_existing_behavior(self): chico = self.Chihuahua("Chico") - self.assertEqual(__, chico.bark()) + self.assertEqual("yip", chico.bark()) fido = self.Dog("Fido") - self.assertEqual(__, fido.bark()) + self.assertEqual("WOOF", fido.bark()) # ------------------------------------------------------------------ @@ -58,7 +58,7 @@ def bark(self): def test_subclasses_can_invoke_parent_behavior_via_super(self): ralph = self.BullDog("Ralph") - self.assertEqual(__, ralph.bark()) + self.assertEqual("WOOF, GRR", ralph.bark()) # ------------------------------------------------------------------ @@ -68,7 +68,7 @@ def growl(self): def test_super_works_across_methods(self): george = self.GreatDane("George") - self.assertEqual(__, george.growl()) + self.assertEqual("WOOF, GROWL", george.growl()) # --------------------------------------------------------- @@ -82,8 +82,8 @@ def __init__(self, name): def test_base_init_does_not_get_called_automatically(self): snoopy = self.Pug("Snoopy") - with self.assertRaises(___): name = snoopy.name + with self.assertRaises(AttributeError): name = snoopy.name def test_base_init_has_to_be_called_explicitly(self): boxer = self.Greyhound("Boxer") - self.assertEqual(__, boxer.name) + self.assertEqual("Boxer", boxer.name) diff --git a/koans/about_iteration.py b/koans/about_iteration.py index 1faca8e33..c3dd2ebf7 100644 --- a/koans/about_iteration.py +++ b/koans/about_iteration.py @@ -13,20 +13,20 @@ def test_iterators_are_a_type(self): for num in it: total += num - self.assertEqual(__ , total) + self.assertEqual(15 , total) def test_iterating_with_next(self): stages = iter(['alpha','beta','gamma']) try: - self.assertEqual(__, next(stages)) + self.assertEqual('alpha', next(stages)) next(stages) - self.assertEqual(__, next(stages)) + self.assertEqual('gamma', next(stages)) next(stages) except StopIteration as ex: err_msg = 'Ran out of iterations' - self.assertRegex(err_msg, __) + self.assertRegex(err_msg, 'Ran out of iterations') # ------------------------------------------------------------------ @@ -40,14 +40,14 @@ def test_map_transforms_elements_of_a_list(self): mapping = map(self.add_ten, seq) self.assertNotEqual(list, mapping.__class__) - self.assertEqual(__, mapping.__class__) + self.assertEqual(map, mapping.__class__) # In Python 3 built in iterator funcs return iterable view objects # instead of lists for item in mapping: mapped_seq.append(item) - self.assertEqual(__, mapped_seq) + self.assertEqual([11, 12, 13], mapped_seq) # Note, iterator methods actually return objects of iter type in # python 3. In python 2 map() would give you a list. @@ -62,7 +62,7 @@ def is_even(item): for item in filter(is_even, seq): even_numbers.append(item) - self.assertEqual(__, even_numbers) + self.assertEqual([2, 4, 6], even_numbers) def test_filter_returns_all_items_matching_criterion(self): def is_big_name(item): @@ -71,8 +71,8 @@ def is_big_name(item): names = ["Jim", "Bill", "Clarence", "Doug", "Eli", "Elizabeth"] iterator = filter(is_big_name, names) - self.assertEqual(__, next(iterator)) - self.assertEqual(__, next(iterator)) + self.assertEqual('Clarence', next(iterator)) + self.assertEqual('Elizabeth', next(iterator)) try: next(iterator) @@ -80,7 +80,7 @@ def is_big_name(item): except StopIteration: msg = 'Ran out of big names' - self.assertEquals(__, msg) + self.assertEqual('Ran out of big names', msg) # ------------------------------------------------------------------ @@ -96,13 +96,13 @@ def test_reduce_will_blow_your_mind(self): # to the functools module. result = functools.reduce(self.add, [2, 3, 4]) - self.assertEqual(__, result.__class__) + self.assertEqual(int, result.__class__) # Reduce() syntax is same as Python 2 - self.assertEqual(__, result) + self.assertEqual(9, result) result2 = functools.reduce(self.multiply, [2, 3, 4], 1) - self.assertEqual(__, result2) + self.assertEqual(24, result2) # Extra Credit: # Describe in your own words what reduce does. @@ -113,14 +113,14 @@ def test_use_pass_for_iterations_with_no_body(self): for num in range(1,5): pass - self.assertEqual(__, num) + self.assertEqual(4, num) # ------------------------------------------------------------------ def test_all_iteration_methods_work_on_any_sequence_not_just_lists(self): # Ranges are an iterable sequence result = map(self.add_ten, range(1,4)) - self.assertEqual(__, list(result)) + self.assertEqual([11, 12, 13], list(result)) def test_lines_in_a_file_are_iterable_sequences_too(self): def make_upcase(line): @@ -128,5 +128,5 @@ def make_upcase(line): file = open("example_file.txt") upcase_lines = map(make_upcase, file.readlines()) - self.assertEqual(__, list(upcase_lines)) + self.assertEqual(["This", "Is", "A", "Test"], list(upcase_lines)) file.close() diff --git a/koans/about_lambdas.py b/koans/about_lambdas.py index c1e688094..9362853bd 100644 --- a/koans/about_lambdas.py +++ b/koans/about_lambdas.py @@ -10,7 +10,7 @@ class AboutLambdas(Koan): def test_lambdas_can_be_assigned_to_variables_and_called_explicitly(self): add_one = lambda n: n + 1 - self.assertEqual(__, add_one(10)) + self.assertEqual(11, add_one(10)) # ------------------------------------------------------------------ @@ -21,8 +21,8 @@ def test_accessing_lambda_via_assignment(self): sausages = self.make_order('sausage') eggs = self.make_order('egg') - self.assertEqual(__, sausages(3)) - self.assertEqual(__, eggs(2)) + self.assertEqual("3 sausages", sausages(3)) + self.assertEqual("2 eggs", eggs(2)) def test_accessing_lambda_without_assignment(self): - self.assertEqual(__, self.make_order('spam')(39823)) + self.assertEqual("39823 spams", self.make_order('spam')(39823)) diff --git a/koans/about_list_assignments.py b/koans/about_list_assignments.py index 8a8d48090..0b036f0b0 100644 --- a/koans/about_list_assignments.py +++ b/koans/about_list_assignments.py @@ -10,34 +10,34 @@ class AboutListAssignments(Koan): def test_non_parallel_assignment(self): names = ["John", "Smith"] - self.assertEqual(__, names) + self.assertEqual(["John", "Smith"], names) def test_parallel_assignments(self): first_name, last_name = ["John", "Smith"] - self.assertEqual(__, first_name) - self.assertEqual(__, last_name) + self.assertEqual("John", first_name) + self.assertEqual("Smith", last_name) def test_parallel_assignments_with_extra_values(self): title, *first_names, last_name = ["Sir", "Ricky", "Bobby", "Worthington"] - self.assertEqual(__, title) - self.assertEqual(__, first_names) - self.assertEqual(__, last_name) + self.assertEqual("Sir", title) + self.assertEqual(["Ricky", "Bobby"], first_names) + self.assertEqual("Worthington", last_name) def test_parallel_assignments_with_fewer_values(self): title, *first_names, last_name = ["Mr", "Bond"] - self.assertEqual(__, title) - self.assertEqual(__, first_names) - self.assertEqual(__, last_name) + self.assertEqual("Mr", title) + self.assertEqual([], first_names) + self.assertEqual("Bond", last_name) def test_parallel_assignments_with_sublists(self): first_name, last_name = [["Willie", "Rae"], "Johnson"] - self.assertEqual(__, first_name) - self.assertEqual(__, last_name) + self.assertEqual(["Willie", "Rae"], first_name) + self.assertEqual("Johnson", last_name) def test_swapping_with_parallel_assignment(self): first_name = "Roy" last_name = "Rob" first_name, last_name = last_name, first_name - self.assertEqual(__, first_name) - self.assertEqual(__, last_name) + self.assertEqual("Rob", first_name) + self.assertEqual("Roy", last_name) diff --git a/koans/about_lists.py b/koans/about_lists.py index 61cc3bb29..aa5014cd6 100644 --- a/koans/about_lists.py +++ b/koans/about_lists.py @@ -11,7 +11,7 @@ class AboutLists(Koan): def test_creating_lists(self): empty_list = list() self.assertEqual(list, type(empty_list)) - self.assertEqual(__, len(empty_list)) + self.assertEqual(0, len(empty_list)) def test_list_literals(self): nums = list() @@ -21,70 +21,70 @@ def test_list_literals(self): self.assertEqual([1], nums) nums[1:] = [2] - self.assertListEqual([1, __], nums) + self.assertListEqual([1, 2], nums) nums.append(333) - self.assertListEqual([1, 2, __], nums) + self.assertListEqual([1, 2, 333], nums) def test_accessing_list_elements(self): noms = ['peanut', 'butter', 'and', 'jelly'] - self.assertEqual(__, noms[0]) - self.assertEqual(__, noms[3]) - self.assertEqual(__, noms[-1]) - self.assertEqual(__, noms[-3]) + self.assertEqual('peanut', noms[0]) + self.assertEqual('jelly', noms[3]) + self.assertEqual('jelly', noms[-1]) + self.assertEqual('butter', noms[-3]) def test_slicing_lists(self): noms = ['peanut', 'butter', 'and', 'jelly'] - self.assertEqual(__, noms[0:1]) - self.assertEqual(__, noms[0:2]) - self.assertEqual(__, noms[2:2]) - self.assertEqual(__, noms[2:20]) - self.assertEqual(__, noms[4:0]) - self.assertEqual(__, noms[4:100]) - self.assertEqual(__, noms[5:0]) + self.assertEqual(['peanut'], noms[0:1]) + self.assertEqual(['peanut', 'butter'], noms[0:2]) + self.assertEqual([], noms[2:2]) + self.assertEqual(['and', 'jelly'], noms[2:20]) + self.assertEqual([], noms[4:0]) + self.assertEqual([], noms[4:100]) + self.assertEqual([], noms[5:0]) def test_slicing_to_the_edge(self): noms = ['peanut', 'butter', 'and', 'jelly'] - self.assertEqual(__, noms[2:]) - self.assertEqual(__, noms[:2]) + self.assertEqual(['and', 'jelly'], noms[2:]) + self.assertEqual(['peanut', 'butter'], noms[:2]) def test_lists_and_ranges(self): self.assertEqual(range, type(range(5))) self.assertNotEqual([1, 2, 3, 4, 5], range(1,6)) - self.assertEqual(__, list(range(5))) - self.assertEqual(__, list(range(5, 9))) + self.assertEqual([0, 1, 2, 3, 4], list(range(5))) + self.assertEqual([5, 6, 7, 8], list(range(5, 9))) def test_ranges_with_steps(self): - self.assertEqual(__, list(range(5, 3, -1))) - self.assertEqual(__, list(range(0, 8, 2))) - self.assertEqual(__, list(range(1, 8, 3))) - self.assertEqual(__, list(range(5, -7, -4))) - self.assertEqual(__, list(range(5, -8, -4))) + self.assertEqual([5, 4], list(range(5, 3, -1))) + self.assertEqual([0, 2, 4, 6], list(range(0, 8, 2))) + self.assertEqual([1, 4, 7], list(range(1, 8, 3))) + self.assertEqual([5, 1, -3], list(range(5, -7, -4))) + self.assertEqual([5, 1, -3, -7], list(range(5, -8, -4))) def test_insertions(self): knight = ['you', 'shall', 'pass'] knight.insert(2, 'not') - self.assertEqual(__, knight) + self.assertEqual(['you', 'shall', 'not', 'pass'], knight) knight.insert(0, 'Arthur') - self.assertEqual(__, knight) + self.assertEqual(['Arthur', 'you', 'shall', 'not', 'pass'], knight) def test_popping_lists(self): stack = [10, 20, 30, 40] stack.append('last') - self.assertEqual(__, stack) + self.assertEqual([10, 20, 30, 40, 'last'], stack) popped_value = stack.pop() - self.assertEqual(__, popped_value) - self.assertEqual(__, stack) + self.assertEqual('last', popped_value) + self.assertEqual([10, 20, 30, 40], stack) popped_value = stack.pop(1) - self.assertEqual(__, popped_value) - self.assertEqual(__, stack) + self.assertEqual(20, popped_value) + self.assertEqual([10, 30, 40], stack) # Notice that there is a "pop" but no "push" in python? @@ -98,11 +98,11 @@ def test_making_queues(self): queue = [1, 2] queue.append('last') - self.assertEqual(__, queue) + self.assertEqual([1, 2, 'last'], queue) popped_value = queue.pop(0) - self.assertEqual(__, popped_value) - self.assertEqual(__, queue) + self.assertEqual(1, popped_value) + self.assertEqual([2, 'last'], queue) # Note, popping from the left hand side of a list is # inefficient. Use collections.deque instead. diff --git a/koans/about_method_bindings.py b/koans/about_method_bindings.py index 020851bd5..69dc0ec5e 100644 --- a/koans/about_method_bindings.py +++ b/koans/about_method_bindings.py @@ -16,42 +16,42 @@ def method(self): class AboutMethodBindings(Koan): def test_methods_are_bound_to_an_object(self): obj = Class() - self.assertEqual(__, obj.method.__self__ == obj) + self.assertEqual(True, obj.method.__self__ == obj) def test_methods_are_also_bound_to_a_function(self): obj = Class() - self.assertEqual(__, obj.method()) - self.assertEqual(__, obj.method.__func__(obj)) + self.assertEqual("parrot", obj.method()) + self.assertEqual("parrot", obj.method.__func__(obj)) def test_functions_have_attributes(self): obj = Class() - self.assertEqual(__, len(dir(function))) - self.assertEqual(__, dir(function) == dir(obj.method.__func__)) + self.assertEqual(38, len(dir(function))) + self.assertEqual(True, dir(function) == dir(obj.method.__func__)) def test_methods_have_different_attributes(self): obj = Class() - self.assertEqual(__, len(dir(obj.method))) + self.assertEqual(28, len(dir(obj.method))) def test_setting_attributes_on_an_unbound_function(self): function.cherries = 3 - self.assertEqual(__, function.cherries) + self.assertEqual(3, function.cherries) def test_setting_attributes_on_a_bound_method_directly(self): obj = Class() - with self.assertRaises(___): obj.method.cherries = 3 + with self.assertRaises(AttributeError): obj.method.cherries = 3 def test_setting_attributes_on_methods_by_accessing_the_inner_function(self): obj = Class() obj.method.__func__.cherries = 3 - self.assertEqual(__, obj.method.cherries) + self.assertEqual(3, obj.method.cherries) def test_functions_can_have_inner_functions(self): function2.get_fruit = function - self.assertEqual(__, function2.get_fruit()) + self.assertEqual("pineapple", function2.get_fruit()) def test_inner_functions_are_unbound(self): function2.get_fruit = function - with self.assertRaises(___): cls = function2.get_fruit.__self__ + with self.assertRaises(AttributeError): cls = function2.get_fruit.__self__ # ------------------------------------------------------------------ @@ -68,8 +68,8 @@ def test_get_descriptor_resolves_attribute_binding(self): # binding_owner = obj # owner_type = cls - self.assertEqual(__, bound_obj.__class__.__name__) - self.assertEqual(__, binding_owner.__class__.__name__) + self.assertEqual("BoundClass", bound_obj.__class__.__name__) + self.assertEqual("AboutMethodBindings", binding_owner.__class__.__name__) self.assertEqual(AboutMethodBindings, owner_type) # ------------------------------------------------------------------ @@ -86,5 +86,5 @@ def __set__(self, obj, val): def test_set_descriptor_changes_behavior_of_attribute_assignment(self): self.assertEqual(None, self.color.choice) self.color = 'purple' - self.assertEqual(__, self.color.choice) + self.assertEqual("purple", self.color.choice) diff --git a/koans/about_methods.py b/koans/about_methods.py index 796a07ea5..c7129da58 100644 --- a/koans/about_methods.py +++ b/koans/about_methods.py @@ -12,7 +12,7 @@ def my_global_function(a,b): class AboutMethods(Koan): def test_calling_a_global_function(self): - self.assertEqual(__, my_global_function(2,3)) + self.assertEqual(5, my_global_function(2,3)) # NOTE: Wrong number of arguments is not a SYNTAX error, but a # runtime error. @@ -33,7 +33,7 @@ def test_calling_functions_with_wrong_number_of_arguments(self): msg = e.args[0] # Note, watch out for parenthesis. They need slashes in front! - self.assertRegex(msg, __) + self.assertRegex(msg, r'my_global_function\(\) takes 2 positional arguments but 3 were given') # ------------------------------------------------------------------ @@ -41,7 +41,7 @@ def pointless_method(self, a, b): sum = a + b def test_which_does_not_return_anything(self): - self.assertEqual(__, self.pointless_method(1, 2)) + self.assertEqual(None, self.pointless_method(1, 2)) # Notice that methods accessed from class scope do not require # you to pass the first "self" argument? @@ -51,8 +51,8 @@ def method_with_defaults(self, a, b='default_value'): return [a, b] def test_calling_with_default_values(self): - self.assertEqual(__, self.method_with_defaults(1)) - self.assertEqual(__, self.method_with_defaults(1, 2)) + self.assertEqual([1, 'default_value'], self.method_with_defaults(1)) + self.assertEqual([1, 2], self.method_with_defaults(1, 2)) # ------------------------------------------------------------------ @@ -60,9 +60,9 @@ def method_with_var_args(self, *args): return args def test_calling_with_variable_arguments(self): - self.assertEqual(__, self.method_with_var_args()) + self.assertEqual((), self.method_with_var_args()) self.assertEqual(('one',), self.method_with_var_args('one')) - self.assertEqual(__, self.method_with_var_args('one', 'two')) + self.assertEqual(('one', 'two'), self.method_with_var_args('one', 'two')) # ------------------------------------------------------------------ @@ -73,13 +73,13 @@ def test_functions_without_self_arg_are_global_functions(self): def function_with_the_same_name(a, b): return a * b - self.assertEqual(__, function_with_the_same_name(3,4)) + self.assertEqual(12, function_with_the_same_name(3,4)) def test_calling_methods_in_same_class_with_explicit_receiver(self): def function_with_the_same_name(a, b): return a * b - self.assertEqual(__, self.function_with_the_same_name(3,4)) + self.assertEqual(7, self.function_with_the_same_name(3,4)) # ------------------------------------------------------------------ @@ -92,10 +92,10 @@ def another_method_with_the_same_name(self): return 42 def test_that_old_methods_are_hidden_by_redefinitions(self): - self.assertEqual(__, self.another_method_with_the_same_name()) + self.assertEqual(42, self.another_method_with_the_same_name()) def test_that_overlapped_method_is_still_there(self): - self.assertEqual(__, self.link_to_overlapped_method()) + self.assertEqual(10, self.link_to_overlapped_method()) # ------------------------------------------------------------------ @@ -103,21 +103,21 @@ def empty_method(self): pass def test_methods_that_do_nothing_need_to_use_pass_as_a_filler(self): - self.assertEqual(__, self.empty_method()) + self.assertEqual(None, self.empty_method()) def test_pass_does_nothing_at_all(self): "You" "shall" "not" pass - self.assertEqual(____, "Still got to this line" != None) + self.assertEqual(True, "Still got to this line" != None) # ------------------------------------------------------------------ def one_line_method(self): return 'Madagascar' def test_no_indentation_required_for_one_line_statement_bodies(self): - self.assertEqual(__, self.one_line_method()) + self.assertEqual('Madagascar', self.one_line_method()) # ------------------------------------------------------------------ @@ -126,7 +126,7 @@ def method_with_documentation(self): return "ok" def test_the_documentation_can_be_viewed_with_the_doc_method(self): - self.assertRegex(self.method_with_documentation.__doc__, __) + self.assertRegex(self.method_with_documentation.__doc__, "A string placed at the beginning of a function is used for documentation") # ------------------------------------------------------------------ @@ -143,20 +143,20 @@ def __password(self): def test_calling_methods_in_other_objects(self): rover = self.Dog() - self.assertEqual(__, rover.name()) + self.assertEqual("Fido", rover.name()) def test_private_access_is_implied_but_not_enforced(self): rover = self.Dog() # This is a little rude, but legal - self.assertEqual(__, rover._tail()) + self.assertEqual("wagging", rover._tail()) def test_attributes_with_double_underscore_prefixes_are_subject_to_name_mangling(self): rover = self.Dog() - with self.assertRaises(___): password = rover.__password() + with self.assertRaises(AttributeError): password = rover.__password() # But this still is! - self.assertEqual(__, rover._Dog__password()) + self.assertEqual("password", rover._Dog__password()) # Name mangling exists to avoid name clash issues when subclassing. # It is not for providing effective access protection diff --git a/koans/about_modules.py b/koans/about_modules.py index 7a266171d..cfa845244 100644 --- a/koans/about_modules.py +++ b/koans/about_modules.py @@ -17,21 +17,21 @@ def test_importing_other_python_scripts_as_modules(self): from . import local_module # local_module.py duck = local_module.Duck() - self.assertEqual(__, duck.name) + self.assertEqual("Daffy", duck.name) def test_importing_attributes_from_classes_using_from_keyword(self): from .local_module import Duck duck = Duck() # no module qualifier needed this time - self.assertEqual(__, duck.name) + self.assertEqual("Daffy", duck.name) def test_we_can_import_multiple_items_at_once(self): from . import jims, joes jims_dog = jims.Dog() joes_dog = joes.Dog() - self.assertEqual(__, jims_dog.identify()) - self.assertEqual(__, joes_dog.identify()) + self.assertEqual("jims dog", jims_dog.identify()) + self.assertEqual("joes dog", joes_dog.identify()) def test_importing_all_module_attributes_at_once(self): """ @@ -43,18 +43,18 @@ def test_importing_all_module_attributes_at_once(self): goose = Goose() hamster = Hamster() - self.assertEqual(__, goose.name) - self.assertEqual(__, hamster.name) + self.assertEqual("Mr Stabby", goose.name) + self.assertEqual("Phil", hamster.name) def test_modules_hide_attributes_prefixed_by_underscores(self): - with self.assertRaises(___): + with self.assertRaises(NameError): private_squirrel = _SecretSquirrel() def test_private_attributes_are_still_accessible_in_modules(self): from .local_module import Duck # local_module.py duck = Duck() - self.assertEqual(__, duck._password) + self.assertEqual("password", duck._password) # module level attribute hiding doesn't affect class attributes # (unless the class itself is hidden). @@ -66,12 +66,12 @@ def test_a_module_can_limit_wildcard_imports(self): # 'Goat' is on the __all__ list goat = Goat() - self.assertEqual(__, goat.name) + self.assertEqual("George", goat.name) # How about velociraptors? lizard = _Velociraptor() - self.assertEqual(__, lizard.name) + self.assertEqual("Cuddles", lizard.name) # SecretDuck? Never heard of her! - with self.assertRaises(___): + with self.assertRaises(NameError): duck = SecretDuck() diff --git a/koans/about_monkey_patching.py b/koans/about_monkey_patching.py index bdea2b8b9..0f1db7d63 100644 --- a/koans/about_monkey_patching.py +++ b/koans/about_monkey_patching.py @@ -14,7 +14,7 @@ def bark(self): def test_as_defined_dogs_do_bark(self): fido = self.Dog() - self.assertEqual(__, fido.bark()) + self.assertEqual("WOOF", fido.bark()) # ------------------------------------------------------------------ @@ -24,8 +24,8 @@ def wag(self): return "HAPPY" self.Dog.wag = wag fido = self.Dog() - self.assertEqual(__, fido.wag()) - self.assertEqual(__, fido.bark()) + self.assertEqual("HAPPY", fido.wag()) + self.assertEqual("WOOF", fido.bark()) # ------------------------------------------------------------------ @@ -35,7 +35,7 @@ def test_most_built_in_classes_cannot_be_monkey_patched(self): except Exception as ex: err_msg = ex.args[0] - self.assertRegex(err_msg, __) + self.assertRegex(err_msg, "cannot set 'is_even' attribute of immutable type 'int'") # ------------------------------------------------------------------ @@ -44,5 +44,5 @@ class MyInt(int): pass def test_subclasses_of_built_in_classes_can_be_be_monkey_patched(self): self.MyInt.is_even = lambda self: (self % 2) == 0 - self.assertEqual(__, self.MyInt(1).is_even()) - self.assertEqual(__, self.MyInt(2).is_even()) + self.assertEqual(False, self.MyInt(1).is_even()) + self.assertEqual(True, self.MyInt(2).is_even()) diff --git a/koans/about_multiple_inheritance.py b/koans/about_multiple_inheritance.py index 4227f7eb9..d5ef2df26 100644 --- a/koans/about_multiple_inheritance.py +++ b/koans/about_multiple_inheritance.py @@ -87,7 +87,7 @@ def here(self): def test_normal_methods_are_available_in_the_object(self): jeff = self.Spiderpig() - self.assertRegex(jeff.speak(), __) + self.assertRegex(jeff.speak(), "This looks like a job for Spiderpig!") def test_base_class_methods_are_also_available_in_the_object(self): jeff = self.Spiderpig() @@ -95,22 +95,22 @@ def test_base_class_methods_are_also_available_in_the_object(self): jeff.set_name("Rover") except: self.fail("This should not happen") - self.assertEqual(__, jeff.can_climb_walls()) + self.assertEqual(True, jeff.can_climb_walls()) def test_base_class_methods_can_affect_instance_variables_in_the_object(self): jeff = self.Spiderpig() - self.assertEqual(__, jeff.name) + self.assertEqual("Jeff", jeff.name) jeff.set_name("Rover") - self.assertEqual(__, jeff.name) + self.assertEqual("Rover", jeff.name) def test_left_hand_side_inheritance_tends_to_be_higher_priority(self): jeff = self.Spiderpig() - self.assertEqual(__, jeff.color()) + self.assertEqual("pink", jeff.color()) def test_super_class_methods_are_higher_priority_than_super_super_classes(self): jeff = self.Spiderpig() - self.assertEqual(__, jeff.legs()) + self.assertEqual(8, jeff.legs()) def test_we_can_inspect_the_method_resolution_order(self): # @@ -119,10 +119,10 @@ def test_we_can_inspect_the_method_resolution_order(self): mro = type(self.Spiderpig()).mro() self.assertEqual('Spiderpig', mro[0].__name__) self.assertEqual('Pig', mro[1].__name__) - self.assertEqual(__, mro[2].__name__) - self.assertEqual(__, mro[3].__name__) - self.assertEqual(__, mro[4].__name__) - self.assertEqual(__, mro[5].__name__) + self.assertEqual('Spider', mro[2].__name__) + self.assertEqual('Animal', mro[3].__name__) + self.assertEqual('Nameable', mro[4].__name__) + self.assertEqual('object', mro[5].__name__) def test_confirm_the_mro_controls_the_calling_order(self): jeff = self.Spiderpig() @@ -132,7 +132,7 @@ def test_confirm_the_mro_controls_the_calling_order(self): self.assertRegex(next.here(), 'Pig') next = super(AboutMultipleInheritance.Pig, jeff) - self.assertRegex(next.here(), __) + self.assertRegex(next.here(), 'Spider') # Hang on a minute?!? That last class name might be a super class of # the 'jeff' object, but its hardly a superclass of Pig, is it? diff --git a/koans/about_none.py b/koans/about_none.py index 1731f0108..cf230cef9 100644 --- a/koans/about_none.py +++ b/koans/about_none.py @@ -11,11 +11,11 @@ class AboutNone(Koan): def test_none_is_an_object(self): "Unlike NULL in a lot of languages" - self.assertEqual(__, isinstance(None, object)) + self.assertEqual(True, isinstance(None, object)) def test_none_is_universal(self): "There is only one None" - self.assertEqual(____, None is None) + self.assertEqual(True, None is None) def test_what_exception_do_you_get_when_calling_nonexistent_methods(self): """ @@ -37,15 +37,15 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self): # # https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute - self.assertEqual(__, ex2.__class__) + self.assertEqual(AttributeError, ex2.__class__) # What message was attached to the exception? # (HINT: replace __ with part of the error message.) - self.assertRegex(ex2.args[0], __) + self.assertRegex(ex2.args[0], "object has no attribute") def test_none_is_distinct(self): """ None is distinct from other things which are False. """ - self.assertEqual(__, None is not 0) - self.assertEqual(__, None is not False) + self.assertEqual(True, None is not 0) + self.assertEqual(True, None is not False) diff --git a/koans/about_packages.py b/koans/about_packages.py index 69288a1c8..347ce5662 100644 --- a/koans/about_packages.py +++ b/koans/about_packages.py @@ -29,13 +29,13 @@ def test_subfolders_can_form_part_of_a_module_package(self): from .a_package_folder.a_module import Duck duck = Duck() - self.assertEqual(__, duck.name) + self.assertEqual("Donald", duck.name) def test_subfolders_become_modules_if_they_have_an_init_module(self): # Import ./a_package_folder/__init__.py from .a_package_folder import an_attribute - self.assertEqual(__, an_attribute) + self.assertEqual(1984, an_attribute) # ------------------------------------------------------------------ @@ -43,7 +43,7 @@ def test_use_absolute_imports_to_import_upper_level_modules(self): # Import /contemplate_koans.py import contemplate_koans - self.assertEqual(__, contemplate_koans.__name__) + self.assertEqual('contemplate_koans', contemplate_koans.__name__) # contemplate_koans.py is the root module in this package because it's # the first python module called in koans. @@ -57,4 +57,4 @@ def test_import_a_module_in_a_subfolder_folder_using_an_absolute_path(self): # Import contemplate_koans.py/koans/a_package_folder/a_module.py from koans.a_package_folder.a_module import Duck - self.assertEqual(__, Duck.__module__) + self.assertEqual("koans.a_package_folder.a_module", Duck.__module__) diff --git a/koans/about_proxy_object_project.py b/koans/about_proxy_object_project.py index db70e0c70..4eed07165 100644 --- a/koans/about_proxy_object_project.py +++ b/koans/about_proxy_object_project.py @@ -20,12 +20,31 @@ class Proxy: def __init__(self, target_object): - # WRITE CODE HERE + self._messages = [] #initialize '_obj' attribute last. Trust me on this! self._obj = target_object - # WRITE CODE HERE + def __setattr__(self, attr_name, value): + if attr_name[0] == '_': + object.__setattr__(self, attr_name, value) + else: + self._messages.append(attr_name) + self._obj.__setattr__(attr_name, value) + + def __getattr__(self, attr_name): + # print("in getattr {0} {1}".format(self._obj.__class__, attr_name)) + self._messages.append(attr_name) + return object.__getattribute__(self._obj, attr_name) + + def messages(self): + return self._messages + + def was_called(self, message_name): + return self.number_of_times_called(message_name) > 0 + + def number_of_times_called(self, message_name): + return self._messages.count(message_name) # The proxy object should pass the following Koan: # diff --git a/koans/about_regex.py b/koans/about_regex.py index f562594e5..d63828352 100644 --- a/koans/about_regex.py +++ b/koans/about_regex.py @@ -20,7 +20,7 @@ def test_matching_literal_text(self): """ string = "Hello, my name is Felix and these koans are based " + \ "on Ben's book: Regular Expressions in 10 minutes." - m = re.search(__, string) + m = re.search(r"F\w+", string) self.assertTrue( m and m.group(0) and m.group(0) == 'Felix', @@ -46,10 +46,10 @@ def test_matching_literal_text_how_many(self): string = ("Hello, my name is Felix and these koans are based " + "on Ben's book: Regular Expressions in 10 minutes. " + "Repeat My name is Felix") - m = re.match('Felix', string) # TIP: match may not be the best option + m = re.findall('Felix', string) # TIP: match may not be the best option # I want to know how many times my name appears - self.assertEqual(m, __) + self.assertEqual(2, len(m)) def test_matching_literal_text_not_case_sensitivity(self): """ @@ -63,8 +63,8 @@ def test_matching_literal_text_not_case_sensitivity(self): string = "Hello, my name is Felix or felix and this koan " + \ "is based on Ben's book: Regular Expressions in 10 minutes." - self.assertEqual(re.findall("felix", string), __) - self.assertEqual(re.findall("felix", string, re.IGNORECASE), __) + self.assertEqual(re.findall("felix", string), ['felix']) + self.assertEqual(re.findall("felix", string, re.IGNORECASE), ['Felix', 'felix']) def test_matching_any_character(self): """ @@ -81,8 +81,8 @@ def test_matching_any_character(self): + "sa1.xls" # I want to find all uses of myArray - change_this_search_string = 'a..xlx' - self.assertEquals( + change_this_search_string = 'a..xls' + self.assertEqual( len(re.findall(change_this_search_string, string)), 3) @@ -107,8 +107,8 @@ def test_matching_set_character(self): # America(sa), but not (ca) TIP you can use the pattern .a. # which matches in above test but in this case matches more than # you want - change_this_search_string = '[nsc]a[2-9].xls' - self.assertEquals( + change_this_search_string = '[ns]a[1-9].xls' + self.assertEqual( len(re.findall(change_this_search_string, string)), 3) @@ -134,7 +134,7 @@ def test_anything_but_matching(self): + "ca1.xls" # I want to find the name 'sam' - change_this_search_string = '[^nc]am' - self.assertEquals( + change_this_search_string = '[^nc]am\.xls' + self.assertEqual( re.findall(change_this_search_string, string), ['sam.xls']) diff --git a/koans/about_scope.py b/koans/about_scope.py index a9cf2a168..5bf77d747 100644 --- a/koans/about_scope.py +++ b/koans/about_scope.py @@ -16,18 +16,18 @@ class AboutScope(Koan): # def test_dog_is_not_available_in_the_current_scope(self): - with self.assertRaises(___): fido = Dog() + with self.assertRaises(NameError): fido = Dog() def test_you_can_reference_nested_classes_using_the_scope_operator(self): fido = jims.Dog() # name 'jims' module name is taken from jims.py filename rover = joes.Dog() - self.assertEqual(__, fido.identify()) - self.assertEqual(__, rover.identify()) + self.assertEqual("jims dog", fido.identify()) + self.assertEqual("joes dog", rover.identify()) - self.assertEqual(__, type(fido) == type(rover)) - self.assertEqual(__, jims.Dog == joes.Dog) + self.assertEqual(False, type(fido) == type(rover)) + self.assertEqual(False, jims.Dog == joes.Dog) # ------------------------------------------------------------------ @@ -35,26 +35,26 @@ class str: pass def test_bare_bones_class_names_do_not_assume_the_current_scope(self): - self.assertEqual(__, AboutScope.str == str) + self.assertEqual(False, AboutScope.str == str) def test_nested_string_is_not_the_same_as_the_system_string(self): - self.assertEqual(__, self.str == type("HI")) + self.assertEqual(False, self.str == type("HI")) def test_str_without_self_prefix_stays_in_the_global_scope(self): - self.assertEqual(__, str == type("HI")) + self.assertEqual(True, str == type("HI")) # ------------------------------------------------------------------ PI = 3.1416 def test_constants_are_defined_with_an_initial_uppercase_letter(self): - self.assertAlmostEqual(_____, self.PI) + self.assertAlmostEqual(3.1416, self.PI) # Note, floating point numbers in python are not precise. # assertAlmostEqual will check that it is 'close enough' def test_constants_are_assumed_by_convention_only(self): self.PI = "rhubarb" - self.assertEqual(_____, self.PI) + self.assertEqual("rhubarb", self.PI) # There aren't any real constants in python. Its up to the developer # to keep to the convention and not modify them. @@ -71,13 +71,13 @@ def test_incrementing_with_local_counter(self): global counter start = counter self.increment_using_local_counter(start) - self.assertEqual(__, counter == start + 1) + self.assertEqual(False, counter == start + 1) def test_incrementing_with_global_counter(self): global counter start = counter self.increment_using_global_counter() - self.assertEqual(__, counter == start + 1) + self.assertEqual(True, counter == start + 1) # ------------------------------------------------------------------ @@ -96,10 +96,10 @@ def from_the_boosh(): return from_the_boosh() def test_getting_something_locally(self): - self.assertEqual(__, self.local_access()) + self.assertEqual("this is a local shop for local people", self.local_access()) def test_getting_something_nonlocally(self): - self.assertEqual(__, self.nonlocal_access()) + self.assertEqual("eels", self.nonlocal_access()) # ------------------------------------------------------------------ @@ -107,4 +107,4 @@ def test_getting_something_nonlocally(self): deadly_bingo = [4, 8, 15, 16, 23, 42] def test_global_attributes_can_be_created_in_the_middle_of_a_class(self): - self.assertEqual(__, deadly_bingo[5]) + self.assertEqual(42, deadly_bingo[5]) diff --git a/koans/about_scoring_project.py b/koans/about_scoring_project.py index 0fd055de2..e66a8ebc7 100644 --- a/koans/about_scoring_project.py +++ b/koans/about_scoring_project.py @@ -1,6 +1,7 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- +from collections import defaultdict from runner.koan import * # Greed is a dice game where you roll up to five dice to accumulate @@ -33,8 +34,35 @@ # Your goal is to write the score method. def score(dice): - # You need to write this method - pass + return score_plus(dice)[0] + +def score_plus(dice): + if len(dice) > 5: + raise ValueError() + + score = 0 + non_scoring = len(dice) + + counts = defaultdict(int) + for num in dice: + counts[num] += 1 + + for num, count in counts.items(): + if (count >= 3): + count -= 3 + non_scoring -= 3 + if (num == 1): + score += 1000 + else: + score += num * 100 + if num == 1: + score += count * 100 + non_scoring -= count + if num == 5: + score += count * 50 + non_scoring -= count + + return (score, non_scoring) class AboutScoringProject(Koan): def test_score_of_an_empty_list_is_zero(self): @@ -70,3 +98,8 @@ def test_score_of_mixed_is_sum(self): def test_ones_not_left_out(self): self.assertEqual(300, score([1,2,2,2])) self.assertEqual(350, score([1,5,2,2,2])) + + def test_score_plus(self): + self.assertEqual((500+100, 1), score_plus([5, 5, 1, 5, 3])) + self.assertEqual((500+100+100, 0), score_plus([5, 5, 1, 5, 1])) + self.assertEqual((0, 5), score_plus([2, 3, 4, 6, 6])) \ No newline at end of file diff --git a/koans/about_sets.py b/koans/about_sets.py index 87cf10959..d125a7d90 100644 --- a/koans/about_sets.py +++ b/koans/about_sets.py @@ -9,27 +9,27 @@ def test_sets_make_keep_lists_unique(self): there_can_only_be_only_one = set(highlanders) - self.assertEqual(__, there_can_only_be_only_one) + self.assertEqual({'MacLeod', 'Ramirez', 'Matunas', 'Malcolm'}, there_can_only_be_only_one) def test_empty_sets_have_different_syntax_to_populated_sets(self): - self.assertEqual(__, {1, 2, 3}) - self.assertEqual(__, set()) + self.assertEqual({1, 2, 3}, {1, 2, 3}) + self.assertEqual(set(), set()) def test_dictionaries_and_sets_use_same_curly_braces(self): # Note: Literal sets using braces were introduced in python 3. # They were also backported to python 2.7. - self.assertEqual(__, {1, 2, 3}.__class__) - self.assertEqual(__, {'one': 1, 'two': 2}.__class__) + self.assertEqual(set, {1, 2, 3}.__class__) + self.assertEqual(dict, {'one': 1, 'two': 2}.__class__) - self.assertEqual(__, {}.__class__) + self.assertEqual(dict, {}.__class__) def test_creating_sets_using_strings(self): - self.assertEqual(__, {'12345'}) - self.assertEqual(__, set('12345')) + self.assertEqual({'12345'}, {'12345'}) + self.assertEqual({'1', '2', '3', '4', '5'}, set('12345')) def test_convert_the_set_into_a_list_to_sort_it(self): - self.assertEqual(__, sorted(set('12345'))) + self.assertEqual(['1', '2', '3', '4', '5'], sorted(set('12345'))) # ------------------------------------------------------------------ @@ -37,19 +37,19 @@ def test_set_have_arithmetic_operators(self): scotsmen = {'MacLeod', 'Wallace', 'Willie'} warriors = {'MacLeod', 'Wallace', 'Leonidas'} - self.assertEqual(__, scotsmen - warriors) - self.assertEqual(__, scotsmen | warriors) - self.assertEqual(__, scotsmen & warriors) - self.assertEqual(__, scotsmen ^ warriors) + self.assertEqual({'Willie'}, scotsmen - warriors) + self.assertEqual({'MacLeod', 'Wallace', 'Willie', 'Leonidas'}, scotsmen | warriors) + self.assertEqual({'MacLeod', 'Wallace'}, scotsmen & warriors) + self.assertEqual({'Willie', 'Leonidas'}, scotsmen ^ warriors) # ------------------------------------------------------------------ def test_we_can_query_set_membership(self): - self.assertEqual(__, 127 in {127, 0, 0, 1} ) - self.assertEqual(__, 'cow' not in set('apocalypse now') ) + self.assertEqual(True, 127 in {127, 0, 0, 1} ) + self.assertEqual(True, 'cow' not in set('apocalypse now') ) def test_we_can_compare_subsets(self): - self.assertEqual(__, set('cake') <= set('cherry cake')) - self.assertEqual(__, set('cake').issubset(set('cherry cake')) ) + self.assertEqual(True, set('cake') <= set('cherry cake')) + self.assertEqual(True, set('cake').issubset(set('cherry cake')) ) - self.assertEqual(__, set('cake') > set('pie')) + self.assertEqual(False, set('cake') > set('pie')) diff --git a/koans/about_string_manipulation.py b/koans/about_string_manipulation.py index 5204f29ba..3465c0ccb 100644 --- a/koans/about_string_manipulation.py +++ b/koans/about_string_manipulation.py @@ -9,13 +9,13 @@ def test_use_format_to_interpolate_variables(self): value1 = 'one' value2 = 2 string = "The values are {0} and {1}".format(value1, value2) - self.assertEqual(__, string) + self.assertEqual("The values are one and 2", string) def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self): value1 = 'doh' value2 = 'DOH' string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2) - self.assertEqual(__, string) + self.assertEqual("The values are DOH, doh, doh and DOH!", string) def test_any_python_expression_may_be_interpolated(self): import math # import a standard python module with math functions @@ -23,24 +23,24 @@ def test_any_python_expression_may_be_interpolated(self): decimal_places = 4 string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5), decimal_places) - self.assertEqual(__, string) + self.assertEqual("The square root of 5 is 2.2361", string) def test_you_can_get_a_substring_from_a_string(self): string = "Bacon, lettuce and tomato" - self.assertEqual(__, string[7:10]) + self.assertEqual("let", string[7:10]) def test_you_can_get_a_single_character_from_a_string(self): string = "Bacon, lettuce and tomato" - self.assertEqual(__, string[1]) + self.assertEqual("a", string[1]) def test_single_characters_can_be_represented_by_integers(self): - self.assertEqual(__, ord('a')) - self.assertEqual(__, ord('b') == (ord('a') + 1)) + self.assertEqual(97, ord('a')) + self.assertEqual(True, ord('b') == (ord('a') + 1)) def test_strings_can_be_split(self): string = "Sausage Egg Cheese" words = string.split() - self.assertListEqual([__, __, __], words) + self.assertListEqual(["Sausage", "Egg", "Cheese"], words) def test_strings_can_be_split_with_different_patterns(self): import re #import python regular expression library @@ -50,25 +50,25 @@ def test_strings_can_be_split_with_different_patterns(self): words = pattern.split(string) - self.assertListEqual([__, __, __, __], words) + self.assertListEqual(["the", "rain", "in", "spain"], words) # Pattern is a Python regular expression pattern which matches ',' or ';' def test_raw_strings_do_not_interpret_escape_characters(self): string = r'\n' self.assertNotEqual('\n', string) - self.assertEqual(__, string) - self.assertEqual(__, len(string)) + self.assertEqual("\\n", string) + self.assertEqual(2, len(string)) # Useful in regular expressions, file paths, URLs, etc. def test_strings_can_be_joined(self): words = ["Now", "is", "the", "time"] - self.assertEqual(__, ' '.join(words)) + self.assertEqual("Now is the time", ' '.join(words)) def test_strings_can_change_case(self): - self.assertEqual(__, 'guido'.capitalize()) - self.assertEqual(__, 'guido'.upper()) - self.assertEqual(__, 'TimBot'.lower()) - self.assertEqual(__, 'guido van rossum'.title()) - self.assertEqual(__, 'ToTaLlY aWeSoMe'.swapcase()) + self.assertEqual("Guido", 'guido'.capitalize()) + self.assertEqual("GUIDO", 'guido'.upper()) + self.assertEqual("timbot", 'TimBot'.lower()) + self.assertEqual("Guido Van Rossum", 'guido van rossum'.title()) + self.assertEqual("tOtAlLy AwEsOmE", 'ToTaLlY aWeSoMe'.swapcase()) diff --git a/koans/about_strings.py b/koans/about_strings.py index 25f5f59df..ea0a0a219 100644 --- a/koans/about_strings.py +++ b/koans/about_strings.py @@ -7,88 +7,88 @@ class AboutStrings(Koan): def test_double_quoted_strings_are_strings(self): string = "Hello, world." - self.assertEqual(__, isinstance(string, str)) + self.assertEqual(True, isinstance(string, str)) def test_single_quoted_strings_are_also_strings(self): string = 'Goodbye, world.' - self.assertEqual(__, isinstance(string, str)) + self.assertEqual(True, isinstance(string, str)) def test_triple_quote_strings_are_also_strings(self): string = """Howdy, world!""" - self.assertEqual(__, isinstance(string, str)) + self.assertEqual(True, isinstance(string, str)) def test_triple_single_quotes_work_too(self): string = '''Bonjour tout le monde!''' - self.assertEqual(__, isinstance(string, str)) + self.assertEqual(True, isinstance(string, str)) def test_raw_strings_are_also_strings(self): string = r"Konnichi wa, world!" - self.assertEqual(__, isinstance(string, str)) + self.assertEqual(True, isinstance(string, str)) def test_use_single_quotes_to_create_string_with_double_quotes(self): string = 'He said, "Go Away."' - self.assertEqual(__, string) + self.assertEqual("He said, \"Go Away.\"", string) def test_use_double_quotes_to_create_strings_with_single_quotes(self): string = "Don't" - self.assertEqual(__, string) + self.assertEqual('Don\'t', string) def test_use_backslash_for_escaping_quotes_in_strings(self): a = "He said, \"Don't\"" b = 'He said, "Don\'t"' - self.assertEqual(__, (a == b)) + self.assertEqual(True, (a == b)) def test_use_backslash_at_the_end_of_a_line_to_continue_onto_the_next_line(self): string = "It was the best of times,\n\ It was the worst of times." - self.assertEqual(__, len(string)) + self.assertEqual(52, len(string)) def test_triple_quoted_strings_can_span_lines(self): string = """ Howdy, world! """ - self.assertEqual(__, len(string)) + self.assertEqual(15, len(string)) def test_triple_quoted_strings_need_less_escaping(self): a = "Hello \"world\"." b = """Hello "world".""" - self.assertEqual(__, (a == b)) + self.assertEqual(True, (a == b)) def test_escaping_quotes_at_the_end_of_triple_quoted_string(self): string = """Hello "world\"""" - self.assertEqual(__, string) + self.assertEqual('Hello "world"', string) def test_plus_concatenates_strings(self): string = "Hello, " + "world" - self.assertEqual(__, string) + self.assertEqual("Hello, world", string) def test_adjacent_strings_are_concatenated_automatically(self): string = "Hello" ", " "world" - self.assertEqual(__, string) + self.assertEqual("Hello, world", string) def test_plus_will_not_modify_original_strings(self): hi = "Hello, " there = "world" string = hi + there - self.assertEqual(__, hi) - self.assertEqual(__, there) + self.assertEqual("Hello, ", hi) + self.assertEqual("world", there) def test_plus_equals_will_append_to_end_of_string(self): hi = "Hello, " there = "world" hi += there - self.assertEqual(__, hi) + self.assertEqual("Hello, world", hi) def test_plus_equals_also_leaves_original_string_unmodified(self): original = "Hello, " hi = original there = "world" hi += there - self.assertEqual(__, original) + self.assertEqual("Hello, ", original) def test_most_strings_interpret_escape_characters(self): string = "\n" self.assertEqual('\n', string) self.assertEqual("""\n""", string) - self.assertEqual(__, len(string)) + self.assertEqual(1, len(string)) diff --git a/koans/about_true_and_false.py b/koans/about_true_and_false.py index 5f06a63db..8b0fddec0 100644 --- a/koans/about_true_and_false.py +++ b/koans/about_true_and_false.py @@ -12,32 +12,32 @@ def truth_value(self, condition): return 'false stuff' def test_true_is_treated_as_true(self): - self.assertEqual(__, self.truth_value(True)) + self.assertEqual("true stuff", self.truth_value(True)) def test_false_is_treated_as_false(self): - self.assertEqual(__, self.truth_value(False)) + self.assertEqual("false stuff", self.truth_value(False)) def test_none_is_treated_as_false(self): - self.assertEqual(__, self.truth_value(None)) + self.assertEqual("false stuff", self.truth_value(None)) def test_zero_is_treated_as_false(self): - self.assertEqual(__, self.truth_value(0)) + self.assertEqual("false stuff", self.truth_value(0)) def test_empty_collections_are_treated_as_false(self): - self.assertEqual(__, self.truth_value([])) - self.assertEqual(__, self.truth_value(())) - self.assertEqual(__, self.truth_value({})) - self.assertEqual(__, self.truth_value(set())) + self.assertEqual("false stuff", self.truth_value([])) + self.assertEqual("false stuff", self.truth_value(())) + self.assertEqual("false stuff", self.truth_value({})) + self.assertEqual("false stuff", self.truth_value(set())) def test_blank_strings_are_treated_as_false(self): - self.assertEqual(__, self.truth_value("")) + self.assertEqual("false stuff", self.truth_value("")) def test_everything_else_is_treated_as_true(self): - self.assertEqual(__, self.truth_value(1)) - self.assertEqual(__, self.truth_value([0])) - self.assertEqual(__, self.truth_value((0,))) + self.assertEqual("true stuff", self.truth_value(1)) + self.assertEqual("true stuff", self.truth_value([0])) + self.assertEqual("true stuff", self.truth_value((0,))) self.assertEqual( - __, + "true stuff", self.truth_value("Python is named after Monty Python")) - self.assertEqual(__, self.truth_value(' ')) - self.assertEqual(__, self.truth_value('0')) + self.assertEqual("true stuff", self.truth_value(' ')) + self.assertEqual("true stuff", self.truth_value('0')) diff --git a/koans/about_tuples.py b/koans/about_tuples.py index 1b38c8f7f..4758cc878 100644 --- a/koans/about_tuples.py +++ b/koans/about_tuples.py @@ -6,7 +6,7 @@ class AboutTuples(Koan): def test_creating_a_tuple(self): count_of_three = (1, 2, 5) - self.assertEqual(__, count_of_three[2]) + self.assertEqual(5, count_of_three[2]) def test_tuples_are_immutable_so_item_assignment_is_not_possible(self): @@ -19,11 +19,11 @@ def test_tuples_are_immutable_so_item_assignment_is_not_possible(self): # Note, assertRegex() uses regular expression pattern matching, # so you don't have to copy the whole message. - self.assertRegex(msg, __) + self.assertRegex(msg, "object does not support item assignment") def test_tuples_are_immutable_so_appending_is_not_possible(self): count_of_three = (1, 2, 5) - with self.assertRaises(___): count_of_three.append("boom") + with self.assertRaises(AttributeError): count_of_three.append("boom") # Tuples are less flexible than lists, but faster. @@ -34,26 +34,26 @@ def test_tuples_can_only_be_changed_through_replacement(self): list_count.append("boom") count_of_three = tuple(list_count) - self.assertEqual(__, count_of_three) + self.assertEqual((1, 2, 5, "boom"), count_of_three) def test_tuples_of_one_look_peculiar(self): - self.assertEqual(__, (1).__class__) - self.assertEqual(__, (1,).__class__) - self.assertEqual(__, ("I'm a tuple",).__class__) - self.assertEqual(__, ("Not a tuple").__class__) + self.assertEqual(int, (1).__class__) + self.assertEqual(tuple, (1,).__class__) + self.assertEqual(tuple, ("I'm a tuple",).__class__) + self.assertEqual(str, ("Not a tuple").__class__) def test_tuple_constructor_can_be_surprising(self): - self.assertEqual(__, tuple("Surprise!")) + self.assertEqual(("S", "u", "r", "p", "r", "i", "s", "e", "!"), tuple("Surprise!")) def test_creating_empty_tuples(self): - self.assertEqual(__ , ()) - self.assertEqual(__ , tuple()) # Sometimes less confusing + self.assertEqual(() , ()) + self.assertEqual(() , tuple()) # Sometimes less confusing def test_tuples_can_be_embedded(self): lat = (37, 14, 6, 'N') lon = (115, 48, 40, 'W') place = ('Area 51', lat, lon) - self.assertEqual(__, place) + self.assertEqual(('Area 51', (37, 14, 6, 'N'), (115, 48, 40, 'W')), place) def test_tuples_are_good_for_representing_records(self): locations = [ @@ -63,5 +63,5 @@ def test_tuples_are_good_for_representing_records(self): locations.append( ("Cthulu", (26, 40, 1, 'N'), (70, 45, 7, 'W')) ) - self.assertEqual(__, locations[2][0]) - self.assertEqual(__, locations[0][1][2]) + self.assertEqual("Cthulu", locations[2][0]) + self.assertEqual(15.56, locations[0][1][2]) diff --git a/koans/about_with_statements.py b/koans/about_with_statements.py index 0ae9b5ff8..a1c5ce088 100644 --- a/koans/about_with_statements.py +++ b/koans/about_with_statements.py @@ -22,7 +22,7 @@ def count_lines(self, file_name): self.fail() def test_counting_lines(self): - self.assertEqual(__, self.count_lines("example_file.txt")) + self.assertEqual(4, self.count_lines("example_file.txt")) # ------------------------------------------------------------------ @@ -41,7 +41,7 @@ def find_line(self, file_name): self.fail() def test_finding_lines(self): - self.assertEqual(__, self.find_line("example_file.txt")) + self.assertEqual("test\n", self.find_line("example_file.txt")) ## ------------------------------------------------------------------ ## THINK ABOUT IT: @@ -85,14 +85,18 @@ def count_lines2(self, file_name): return len(file.readlines()) def test_counting_lines2(self): - self.assertEqual(__, self.count_lines2("example_file.txt")) + self.assertEqual(4, self.count_lines2("example_file.txt")) # ------------------------------------------------------------------ def find_line2(self, file_name): # Using the context manager self.FileContextManager, rewrite this # function to return the first line containing the letter 'e'. - return None + with self.FileContextManager(file_name) as file: + for line in file.readlines(): + match = re.search('e', line) + if match: + return line def test_finding_lines2(self): self.assertNotEqual(None, self.find_line2("example_file.txt")) @@ -105,4 +109,4 @@ def count_lines3(self, file_name): return len(file.readlines()) def test_open_already_has_its_own_built_in_context_manager(self): - self.assertEqual(__, self.count_lines3("example_file.txt")) + self.assertEqual(4, self.count_lines3("example_file.txt")) diff --git a/koans/triangle.py b/koans/triangle.py index 4d8d66f42..684fd672d 100644 --- a/koans/triangle.py +++ b/koans/triangle.py @@ -17,8 +17,18 @@ # about_triangle_project_2.py # def triangle(a, b, c): - # DELETE 'PASS' AND WRITE THIS CODE - pass + if (a == 0) or (b == 0) or (c == 0): + raise TriangleError() + + if (a + b <= c) or (a + c <= b) or (b + c <= a): + raise TriangleError() + + if (a == b) and (a == c): + return 'equilateral' + elif (a == b) or (a == c) or (b == c): + return 'isosceles' + else: + return 'scalene' # Error class used in part 2. No need to change this code. class TriangleError(Exception): diff --git a/runner/sensei.py b/runner/sensei.py index 4a8d5cd96..05cbe75f0 100644 --- a/runner/sensei.py +++ b/runner/sensei.py @@ -60,7 +60,7 @@ def sortFailures(self, testClassName): table = list() for test, err in self.failures: if helper.cls_name(test) == testClassName: - m = re.search("(?<= line )\d+" ,err) + m = re.search(r"(?<= line )\d+" ,err) if m: tup = (int(m.group(0)), test, err) table.append(tup) @@ -146,7 +146,7 @@ def scrapeInterestingStackDump(self, err): if m and m.group(0): stack_text += '\n' + line - m = re.search("^ \w(\w)+.*$",line) + m = re.search(r"^ \w(\w)+.*$",line) if m and m.group(0): stack_text += sep + line