From 9bb82f8544ac57de1ab0b30ef87ea1c9f2f711e5 Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Wed, 25 Sep 2013 23:56:31 +0530 Subject: [PATCH 01/10] done solving about_asserts.py --- python2/koans/about_asserts.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/python2/koans/about_asserts.py b/python2/koans/about_asserts.py index 61b53ada1..aeb6c3af8 100644 --- a/python2/koans/about_asserts.py +++ b/python2/koans/about_asserts.py @@ -15,26 +15,26 @@ 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) @@ -42,7 +42,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) @@ -53,7 +53,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): """ @@ -65,14 +65,14 @@ def test_that_sometimes_we_need_to_know_the_class_type(self): # For example, contemplate the text string "naval". What is it's class type? # The koans runner will include this feedback for this koan: # - # AssertionError: '-=> FILL ME IN! <=-' != + # AssertionError: str != # # So "naval".__class__ is equal to ? No not quite. This # is just what it displays. The answer is simply str. # # See for yourself: - self.assertEqual(__, "naval".__class__) # It's str, not + self.assertEqual(str, "naval".__class__) # It's str, not # Need an illustration? More reading can be found here: # From 3e44674d6abe7d729029027abc32f21ee377d8ca Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Thu, 26 Sep 2013 10:16:34 +0530 Subject: [PATCH 02/10] Completed about_strings koans --- python2/koans/about_strings.py | 38 +++++++++++++++++----------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/python2/koans/about_strings.py b/python2/koans/about_strings.py index abfcf5981..4d3f58982 100644 --- a/python2/koans/about_strings.py +++ b/python2/koans/about_strings.py @@ -8,88 +8,88 @@ class AboutStrings(Koan): def test_double_quoted_strings_are_strings(self): string = "Hello, world." - self.assertEqual(__, isinstance(string, basestring)) + self.assertEqual(True, isinstance(string, basestring)) def test_single_quoted_strings_are_also_strings(self): string = 'Goodbye, world.' - self.assertEqual(__, isinstance(string, basestring)) + self.assertEqual(True, isinstance(string, basestring)) def test_triple_quote_strings_are_also_strings(self): string = """Howdy, world!""" - self.assertEqual(__, isinstance(string, basestring)) + self.assertEqual(True, isinstance(string, basestring)) def test_triple_single_quotes_work_too(self): string = '''Bonjour tout le monde!''' - self.assertEqual(__, isinstance(string, basestring)) + self.assertEqual(True, isinstance(string, basestring)) def test_raw_strings_are_also_strings(self): string = r"Konnichi wa, world!" - self.assertEqual(__, isinstance(string, basestring)) + self.assertEqual(True, isinstance(string, basestring)) 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)) From 7fed67fc4648e1585e86007e4daef6f98a6e3026 Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Sat, 28 Sep 2013 22:33:09 +0530 Subject: [PATCH 03/10] Completed about_none --- python2/koans/about_none.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/python2/koans/about_none.py b/python2/koans/about_none.py index e64164dbd..498da5cee 100644 --- a/python2/koans/about_none.py +++ b/python2/koans/about_none.py @@ -12,11 +12,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): # Need a recap on how to evaluate __class__ attributes? # https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute - self.assertEqual(__, ex.__class__) + self.assertEqual(AttributeError, ex.__class__) # What message was attached to the exception? # (HINT: replace __ with part of the error message.) - self.assertMatch(__, ex.args[0]) + self.assertMatch("'NoneType' object has no attribute 'some_method_none_does_not_know_about'", ex.args[0]) 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) From 4ec775b89bfdddf873c798dc898e19e1abf4ac93 Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Sat, 28 Sep 2013 22:56:06 +0530 Subject: [PATCH 04/10] half done with about_lists --- python2/koans/about_lists.py | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/python2/koans/about_lists.py b/python2/koans/about_lists.py index 4d2588272..12b112902 100644 --- a/python2/koans/about_lists.py +++ b/python2/koans/about_lists.py @@ -12,7 +12,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() @@ -22,35 +22,35 @@ def test_list_literals(self): self.assertEqual([1], nums) nums[1:] = [2] - self.assertEqual([1, __], nums) + self.assertEqual([1, 2], nums) nums.append(333) - self.assertEqual([1, 2, __], nums) + self.assertEqual([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(list, type(range(5))) From 32718657de100197fa7ce7547ad7f641e9438c29 Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Sun, 29 Sep 2013 08:58:18 +0530 Subject: [PATCH 05/10] completed the about_lists, had to practise a little bit on the idle --- python2/koans/about_lists.py | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/python2/koans/about_lists.py b/python2/koans/about_lists.py index 12b112902..5ef195190 100644 --- a/python2/koans/about_lists.py +++ b/python2/koans/about_lists.py @@ -54,36 +54,36 @@ def test_slicing_to_the_edge(self): def test_lists_and_ranges(self): self.assertEqual(list, type(range(5))) - self.assertEqual(__, range(5)) - self.assertEqual(__, range(5, 9)) + self.assertEqual([0,1,2,3,4], range(5)) + self.assertEqual([5,6,7,8], range(5, 9)) def test_ranges_with_steps(self): - self.assertEqual(__, range(0, 8, 2)) - self.assertEqual(__, range(1, 8, 3)) - self.assertEqual(__, range(5, -7, -4)) - self.assertEqual(__, range(5, -8, -4)) + self.assertEqual([0,2,4,6], range(0, 8, 2)) + self.assertEqual([1,4,7], range(1, 8, 3)) + self.assertEqual([5,1,-3], range(5, -7, -4)) + self.assertEqual([5,1,-3,-7], 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? @@ -99,8 +99,8 @@ def test_use_deques_for_making_queues(self): queue = deque([1, 2]) queue.append('last') - self.assertEqual(__, list(queue)) + self.assertEqual([1,2,'last'], list(queue)) popped_value = queue.popleft() - self.assertEqual(__, popped_value) - self.assertEqual(__, list(queue)) + self.assertEqual(1, popped_value) + self.assertEqual([2,'last'], list(queue)) From 8e16c6db62db2dbd032aed9046d3e5e335efd9dd Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Sun, 29 Sep 2013 11:51:48 +0530 Subject: [PATCH 06/10] Completed dictionaries, list_assignments, and string manipulation --- python2/koans/about_dictionaries.py | 30 +++++++++---------- python2/koans/about_list_assignments.py | 14 ++++----- python2/koans/about_string_manipulation.py | 34 +++++++++++----------- 3 files changed, 39 insertions(+), 39 deletions(-) diff --git a/python2/koans/about_dictionaries.py b/python2/koans/about_dictionaries.py index 8591b5439..f2868943a 100644 --- a/python2/koans/about_dictionaries.py +++ b/python2/koans/about_dictionaries.py @@ -13,40 +13,40 @@ def test_creating_dictionaries(self): empty_dict = dict() self.assertEqual(dict, type(empty_dict)) self.assertEqual(dict(), 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.assertEqual(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( @@ -54,6 +54,6 @@ def test_making_a_dictionary_from_a_sequence_of_keys(self): '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/python2/koans/about_list_assignments.py b/python2/koans/about_list_assignments.py index 2c0267805..956bf15e0 100644 --- a/python2/koans/about_list_assignments.py +++ b/python2/koans/about_list_assignments.py @@ -11,21 +11,21 @@ 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_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/python2/koans/about_string_manipulation.py b/python2/koans/about_string_manipulation.py index c395309cc..be41a0371 100644 --- a/python2/koans/about_string_manipulation.py +++ b/python2/koans/about_string_manipulation.py @@ -10,13 +10,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 @@ -24,24 +24,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.assertEqual([__, __, __], words) + self.assertEqual(['Sausage', 'Egg','Cheese'], words) def test_strings_can_be_split_with_different_patterns(self): import re # import python regular expression library @@ -51,7 +51,7 @@ def test_strings_can_be_split_with_different_patterns(self): words = pattern.split(string) - self.assertEqual([__, __, __, __], words) + self.assertEqual(['the','rain', 'in','spain'], words) # `pattern` is a Python regular expression pattern which matches # ',' or ';' @@ -59,18 +59,18 @@ def test_strings_can_be_split_with_different_patterns(self): 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()) From d40875306c8efabffc9971e5071d19744401a39e Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Mon, 30 Sep 2013 00:30:10 +0530 Subject: [PATCH 07/10] completed about_tuples --- python2/koans/about_tuples.py | 27 +++++++++++++-------------- 1 file changed, 13 insertions(+), 14 deletions(-) diff --git a/python2/koans/about_tuples.py b/python2/koans/about_tuples.py index 84ba5d552..efcb3f16f 100644 --- a/python2/koans/about_tuples.py +++ b/python2/koans/about_tuples.py @@ -7,14 +7,14 @@ 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): count_of_three = (1, 2, 5) try: count_of_three[2] = "three" except TypeError as ex: - self.assertMatch(__, ex[0]) + self.assertMatch("'tuple' object does not support item assignment", ex[0]) def test_tuples_are_immutable_so_appending_is_not_possible(self): count_of_three = (1, 2, 5) @@ -25,36 +25,35 @@ def test_tuples_are_immutable_so_appending_is_not_possible(self): # Note, assertMatch() uses regular expression pattern matching, # so you don't have to copy the whole message. - self.assertMatch(__, ex[0]) + self.assertMatch("'tuple' object has ", ex[0]) # Tuples are less flexible than lists, but faster. def test_tuples_can_only_be_changed_through_replacement(self): count_of_three = (1, 2, 5) - list_count = list(count_of_three) 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(__, ("Hello comma!", )) + self.assertEqual(int, (1).__class__) + self.assertEqual(tuple, (1,).__class__) + self.assertEqual(('Hello comma!',), ("Hello comma!", )) 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 = [ @@ -66,5 +65,5 @@ def test_tuples_are_good_for_representing_records(self): ("Cthulhu", (26, 40, 1, 'N'), (70, 45, 7, 'W')) ) - self.assertEqual(__, locations[2][0]) - self.assertEqual(__, locations[0][1][2]) + self.assertEqual("Cthulhu", locations[2][0]) + self.assertEqual(15.56, locations[0][1][2]) From 5f660a78b0f5d59ebbc625bb8b11e3801c077ac4 Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Thu, 3 Oct 2013 19:28:30 +0530 Subject: [PATCH 08/10] completed the about_methods lesson --- python2/koans/about_methods.py | 40 +++++++++++++++++----------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/python2/koans/about_methods.py b/python2/koans/about_methods.py index fd924f9c9..03b4c100c 100644 --- a/python2/koans/about_methods.py +++ b/python2/koans/about_methods.py @@ -14,7 +14,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. @@ -24,7 +24,7 @@ def test_calling_functions_with_wrong_number_of_arguments(self): except Exception as exception: # NOTE: The .__name__ attribute will convert the class # into a string value. - self.assertEqual(__, exception.__class__.__name__) + self.assertEqual('TypeError', exception.__class__.__name__) self.assertMatch( r'my_global_function\(\) takes exactly 2 arguments \(0 given\)', exception[0]) @@ -34,7 +34,7 @@ def test_calling_functions_with_wrong_number_of_arguments(self): except Exception as e: # Note, watch out for parenthesis. They need slashes in front! - self.assertMatch(__, e[0]) + self.assertMatch(r'my_global_function\(\) takes exactly 2 arguments \(3 given\)', e[0]) # ------------------------------------------------------------------ @@ -42,7 +42,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? @@ -52,8 +52,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)) # ------------------------------------------------------------------ @@ -61,9 +61,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')) # ------------------------------------------------------------------ @@ -74,13 +74,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)) # ------------------------------------------------------------------ @@ -93,10 +93,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()) # ------------------------------------------------------------------ @@ -104,21 +104,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()) # ------------------------------------------------------------------ @@ -127,7 +127,7 @@ def method_with_documentation(self): return "ok" def test_the_documentation_can_be_viewed_with_the_doc_method(self): - self.assertMatch(__, self.method_with_documentation.__doc__) + self.assertMatch("A string placed at the beginning of a function is used for documentation", self.method_with_documentation.__doc__) # ------------------------------------------------------------------ @@ -144,13 +144,13 @@ 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_double_underscore_attribute_prefixes_cause_name_mangling(self): """Attributes names that start with a double underscore get @@ -160,10 +160,10 @@ def test_double_underscore_attribute_prefixes_cause_name_mangling(self): #This may not be possible... password = rover.__password() except Exception as ex: - self.assertEqual(__, ex.__class__.__name__) + self.assertEqual('AttributeError', ex.__class__.__name__) # 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 From c980c5d5144f5cddd0cef09a4dd02c05637addb2 Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Thu, 3 Oct 2013 19:43:35 +0530 Subject: [PATCH 09/10] completed about_control_statements --- python2/koans/about_control_statements.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/python2/koans/about_control_statements.py b/python2/koans/about_control_statements.py index 921f0bf7f..37c589d87 100644 --- a/python2/koans/about_control_statements.py +++ b/python2/koans/about_control_statements.py @@ -11,13 +11,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_while_statement(self): i = 1 @@ -25,7 +25,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 @@ -34,7 +34,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 @@ -43,14 +43,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 = [ @@ -64,7 +64,7 @@ def test_for_statement_with_tuples(self): result.append("Contestant: '" + knight + \ "' Answer: '" + answer + "'") - text = __ + text ="Contestant: 'Robin' Answer: 'Blue! I mean Green!'" self.assertMatch(text, result[2]) From 6ccdf02100978372b76c214f32644eddb0f4d516 Mon Sep 17 00:00:00 2001 From: Vatsala Dorairajan Date: Wed, 27 May 2015 10:21:03 +0530 Subject: [PATCH 10/10] test push --- Contributor Notes.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/Contributor Notes.txt b/Contributor Notes.txt index 23e32335a..f4a06029f 100644 --- a/Contributor Notes.txt +++ b/Contributor Notes.txt @@ -13,3 +13,4 @@ Running a whole test case: Running a single test: $ python contemplate_koans.py about_strings.AboutStrings.test_triple_quoted_strings_need_less_escaping +yes