diff --git a/.idea/.name b/.idea/.name
new file mode 100644
index 000000000..843bc4c57
--- /dev/null
+++ b/.idea/.name
@@ -0,0 +1 @@
+python_koans
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
new file mode 100644
index 000000000..9a8b7e5c4
--- /dev/null
+++ b/.idea/compiler.xml
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/copyright/profiles_settings.xml b/.idea/copyright/profiles_settings.xml
new file mode 100644
index 000000000..e7bedf337
--- /dev/null
+++ b/.idea/copyright/profiles_settings.xml
@@ -0,0 +1,3 @@
+
+
+
\ No newline at end of file
diff --git a/.idea/encodings.xml b/.idea/encodings.xml
new file mode 100644
index 000000000..d82104827
--- /dev/null
+++ b/.idea/encodings.xml
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 000000000..e1784e6ba
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,174 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ localhost
+ 5050
+
+
+
+
+
+
+ 1.8
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 000000000..0c7c3839e
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/python_koans.iml b/.idea/python_koans.iml
new file mode 100644
index 000000000..5506ded51
--- /dev/null
+++ b/.idea/python_koans.iml
@@ -0,0 +1,14 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/scopes/scope_settings.xml b/.idea/scopes/scope_settings.xml
new file mode 100644
index 000000000..922003b84
--- /dev/null
+++ b/.idea/scopes/scope_settings.xml
@@ -0,0 +1,5 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 000000000..35eb1ddfb
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
new file mode 100644
index 000000000..1e62da7bd
--- /dev/null
+++ b/.idea/workspace.xml
@@ -0,0 +1,318 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ true
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ localhost
+ 5050
+
+
+
+
+
+
+
+
+
+ 1416144838045
+
+ 1416144838045
+
+
+
+ 1416146757941
+
+
+ 1416146757941
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/python2/koans/about_asserts.py b/python2/koans/about_asserts.py
index 476458337..ef6e8d1c3 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):
"""
@@ -72,7 +72,7 @@ def test_that_sometimes_we_need_to_know_the_class_type(self):
#
# 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:
#
diff --git a/python2/koans/about_comprehension.py b/python2/koans/about_comprehension.py
index 4b372732a..a8b337958 100644
--- a/python2/koans/about_comprehension.py
+++ b/python2/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,17 @@ 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(__, len(comprehension[2]))
+ self.assertEqual(['lumberjack', 'inquisitioninquisition',
+ 'spamspamspamspam'], comprehension);
+ self.assertEqual('lumberjack', comprehension[0])
+ self.assertEqual(16, len(comprehension[2]))
def test_double_list_comprehension(self):
list_of_eggs = ['poached egg', 'fried egg']
@@ -40,13 +42,19 @@ 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(__, len(comprehension))
- self.assertEqual(__, comprehension[0])
+ self.assertEqual(['poached egg and lite spam',
+ 'poached egg and ham spam',
+ 'poached egg and fried spam',
+ 'fried egg and lite spam',
+ 'fried egg and ham spam',
+ 'fried egg and fried spam'], comprehension)
+ self.assertEqual(6, len(comprehension))
+ self.assertEqual('poached egg and lite spam', comprehension[0])
def test_creating_a_set_with_set_comprehension(self):
comprehension = { x for x in 'aabbbcccc'}
- self.assertEqual(__, comprehension) # rememeber that set members are unique
+ self.assertEqual({'a', 'b', 'c'}, comprehension) # rememeber that set members are unique
def test_creating_a_dictionary_with_dictionary_comprehension(self):
dict_of_weapons = {'first': 'fear', 'second': 'surprise',
@@ -55,7 +63,13 @@ def test_creating_a_dictionary_with_dictionary_comprehension(self):
dict_comprehension = { k.upper(): weapon for k, weapon in dict_of_weapons.iteritems() 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))
+ self.assertEqual({
+ 'FIRST': 'fear',
+ 'SECOND': 'surprise',
+ 'THIRD': 'ruthless efficiency',
+ 'FORTH': 'fanatical devotion'
+ }, dict_comprehension);
diff --git a/python2/koans/about_control_statements.py b/python2/koans/about_control_statements.py
index 38665cb15..870f954b1 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_if_then_elif_else_statements(self):
if False:
@@ -26,7 +26,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
@@ -34,7 +34,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
@@ -43,7 +43,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
@@ -52,14 +52,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 = [
@@ -73,7 +73,7 @@ def test_for_statement_with_tuples(self):
result.append("Contestant: '" + knight + \
"' Answer: '" + answer + "'")
- text = __
+ text = ".* 'Robin' .* 'Blue! I mean Green!'"
self.assertMatch(text, result[2])
diff --git a/python2/koans/about_dictionaries.py b/python2/koans/about_dictionaries.py
index 8591b5439..8458665db 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_exceptions.py b/python2/koans/about_exceptions.py
index dd2b3823f..61a72bcd9 100644
--- a/python2/koans/about_exceptions.py
+++ b/python2/koans/about_exceptions.py
@@ -11,10 +11,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('StandardError', mro[2].__name__)
+ self.assertEqual('Exception', mro[3].__name__)
+ self.assertEqual('BaseException', mro[4].__name__)
def test_try_clause(self):
result = None
@@ -23,15 +23,15 @@ def test_try_clause(self):
except StandardError as ex:
result = 'exception handled'
- self.assertEqual(__, result)
+ self.assertEqual('exception handled', result)
- self.assertEqual(____, isinstance(ex, StandardError))
- self.assertEqual(____, isinstance(ex, RuntimeError))
+ self.assertEqual(True, isinstance(ex, StandardError))
+ self.assertEqual(False, isinstance(ex, RuntimeError))
self.assertTrue(issubclass(RuntimeError, StandardError), \
"RuntimeError is a subclass of StandardError")
- self.assertEqual(__, ex[0])
+ self.assertEqual('Oops', ex[0])
def test_raising_a_specific_error(self):
result = None
@@ -40,8 +40,8 @@ def test_raising_a_specific_error(self):
except self.MySpecialError as ex:
result = 'exception handled'
- self.assertEqual(__, result)
- self.assertEqual(__, ex[0])
+ self.assertEqual('exception handled', result)
+ self.assertEqual("My Message", ex[0])
def test_else_clause(self):
result = None
@@ -53,7 +53,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):
result = None
@@ -65,4 +65,4 @@ def test_finally_clause(self):
finally:
result = 'always run'
- self.assertEqual(__, result)
+ self.assertEqual('always run', result)
diff --git a/python2/koans/about_generators.py b/python2/koans/about_generators.py
index 5fc239cae..443a4c0de 100644
--- a/python2/koans/about_generators.py
+++ b/python2/koans/about_generators.py
@@ -19,7 +19,11 @@ def test_generating_values_on_the_fly(self):
n in ['crunchy', 'veggie', 'danish'])
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,7 +32,7 @@ def test_generators_are_different_to_list_comprehensions(self):
self.assertEqual(2, num_list[0])
# A generator has to be iterated through.
- 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
@@ -43,8 +47,8 @@ def test_generator_expressions_are_a_one_shot_deal(self):
attempt1 = list(dynamite)
attempt2 = list(dynamite)
- self.assertEqual(__, list(attempt1))
- self.assertEqual(__, list(attempt2))
+ self.assertEqual(['Boom!', 'Boom!', 'Boom!'], list(attempt1))
+ self.assertEqual([], list(attempt2))
# ------------------------------------------------------------------
@@ -55,15 +59,13 @@ def simple_generator_method(self):
yield 'jelly'
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)
+ result = list(self.simple_generator_method())
+ self.assertEqual(['peanut', 'butter', 'and', 'jelly'], result)
def test_coroutines_can_take_arguments(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()
# ------------------------------------------------------------------
@@ -74,7 +76,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))
# ------------------------------------------------------------------
@@ -87,7 +89,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))
# ------------------------------------------------------------------
@@ -105,7 +107,7 @@ def test_generators_can_take_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.generator_with_coroutine()
@@ -113,7 +115,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.assertMatch(__, ex[0])
+ self.assertMatch("can't send non-None value.*", ex[0])
# ------------------------------------------------------------------
@@ -131,11 +133,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/python2/koans/about_iteration.py b/python2/koans/about_iteration.py
index 73adc58e9..fbba12bab 100644
--- a/python2/koans/about_iteration.py
+++ b/python2/koans/about_iteration.py
@@ -14,20 +14,20 @@ def test_iterators_are_a_type(self):
for num in it:
fib += num
- self.assertEqual(__, fib)
+ self.assertEqual(15, fib)
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.assertMatch(__, err_msg)
+ self.assertMatch('.* iterations', err_msg)
# ------------------------------------------------------------------
@@ -38,7 +38,7 @@ def test_map_transforms_elements_of_a_list(self):
seq = [1, 2, 3]
mapped_seq = map(self.add_ten, seq)
- self.assertEqual(__, mapped_seq)
+ self.assertEqual([11, 12, 13], mapped_seq)
def test_filter_selects_certain_items_from_a_list(self):
def is_even(item):
@@ -47,7 +47,7 @@ def is_even(item):
seq = [1, 2, 3, 4, 5, 6]
even_numbers = filter(is_even, seq)
- self.assertEqual(__, even_numbers)
+ self.assertEqual([2, 4, 6], even_numbers)
def test_just_return_first_item_found(self):
def is_big_name(item):
@@ -57,12 +57,12 @@ def is_big_name(item):
# NOTE This still iterates through the whole names, so not particularly
# efficient
- self.assertEqual([__], filter(is_big_name, names)[:1])
+ self.assertEqual(["Clarence"], filter(is_big_name, names)[:1])
# Boring but effective
for item in names:
if is_big_name(item):
- self.assertEqual(__, item)
+ self.assertEqual("Clarence", item)
break
# ------------------------------------------------------------------
@@ -75,28 +75,31 @@ def multiply(self, accum, item):
def test_reduce_will_blow_your_mind(self):
result = reduce(self.add, [2, 3, 4])
- self.assertEqual(__, result)
+ self.assertEqual(9, result)
result2 = reduce(self.multiply, [2, 3, 4], 1)
- self.assertEqual(__, result2)
+ self.assertEqual(24, result2)
# Extra Credit:
# Describe in your own words what reduce does.
+ # Reduce applies the function to each of it's arguments
+ # and feeds the result into it's call with the next argument.
+
# ------------------------------------------------------------------
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))
try:
f = open("example_file.txt")
@@ -105,7 +108,7 @@ def test_all_iteration_methods_work_on_any_sequence_not_just_lists(self):
def make_upcase(line):
return line.strip().upper()
upcase_lines = map(make_upcase, f.readlines())
- self.assertEqual(__, list(upcase_lines))
+ self.assertEqual(['THIS', 'IS', 'A', 'TEST'], list(upcase_lines))
finally:
# Arg, this is ugly.
# We will figure out how to fix this later.
diff --git a/python2/koans/about_lambdas.py b/python2/koans/about_lambdas.py
index dfc72f9e6..fb8352139 100644
--- a/python2/koans/about_lambdas.py
+++ b/python2/koans/about_lambdas.py
@@ -11,7 +11,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))
# ------------------------------------------------------------------
@@ -22,8 +22,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/python2/koans/about_list_assignments.py b/python2/koans/about_list_assignments.py
index 2c0267805..a48e4e6d6 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_lists.py b/python2/koans/about_lists.py
index 4d2588272..6352a78f8 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,68 +22,68 @@ 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)))
- 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))
diff --git a/python2/koans/about_methods.py b/python2/koans/about_methods.py
index fd924f9c9..c6c7f3dc0 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('.* 2 arguments .*', 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,10 @@ def method_with_var_args(self, *args):
return args
def test_calling_with_variable_arguments(self):
- self.assertEqual(__, self.method_with_var_args())
+ # Var args are converted into a tuple that contains them
+ 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 +75,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 +94,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 +105,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 +128,8 @@ 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 +146,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 +162,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
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)
diff --git a/python2/koans/about_scoring_project.py b/python2/koans/about_scoring_project.py
index da51563b4..5ec989062 100644
--- a/python2/koans/about_scoring_project.py
+++ b/python2/koans/about_scoring_project.py
@@ -34,8 +34,37 @@
# Your goal is to write the score method.
def score(dice):
- # You need to write this method
- pass
+ def score_for_three(number):
+ if number == 1:
+ return 1000
+ return number * 100
+
+ def score_for_remaining(number):
+ if number == 1:
+ return 100
+ if number == 5:
+ return 50
+ return 0
+
+ def is_equal(number):
+ return lambda x: x == number
+
+ def score_for_number(number, count):
+ remaining = count
+ score = 0
+ if count > 2:
+ score = score_for_three(number)
+ remaining -= 3
+ score += remaining * score_for_remaining(number)
+ return score
+
+ counts = { number: len(filter(is_equal(number), dice))
+ for number in range(1,7) }
+
+ score = 0
+ for number in range(1,7):
+ score += score_for_number(number, counts[number])
+ return score
class AboutScoringProject(Koan):
diff --git a/python2/koans/about_sets.py b/python2/koans/about_sets.py
index 86403d5d5..4a547e060 100644
--- a/python2/koans/about_sets.py
+++ b/python2/koans/about_sets.py
@@ -11,13 +11,15 @@ 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(set(['MacLeod', 'Ramirez', 'Matunas',
+ 'Malcolm']), there_can_only_be_only_one)
def test_sets_are_unordered(self):
- self.assertEqual(set([__, __, __, __, __]), set('12345'))
+ self.assertEqual(set(['1', '2', '3', '4', '5']), set('12345'))
+ self.assertEqual(set(['1', '3', '2', '5', '4']), set('12345'))
def test_convert_the_set_into_a_list_to_sort_it(self):
- self.assertEqual(__, sorted(set('13245')))
+ self.assertEqual(['1', '2', '3', '4', '5'], sorted(set('13245')))
# ------------------------------------------------------------------
@@ -25,19 +27,22 @@ def test_set_have_arithmetic_operators(self):
scotsmen = set(['MacLeod', 'Wallace', 'Willie'])
warriors = set(['MacLeod', 'Wallace', 'Leonidas'])
- self.assertEqual(__, scotsmen - warriors)
- self.assertEqual(__, scotsmen | warriors)
- self.assertEqual(__, scotsmen & warriors)
- self.assertEqual(__, scotsmen ^ warriors)
+ self.assertEqual(set(['Willie']), scotsmen - warriors)
+ self.assertEqual(
+ set(['MacLeod', 'Wallace', 'Willie', 'Leonidas']),
+ scotsmen | warriors
+ )
+ self.assertEqual(set(['MacLeod', 'Wallace']), scotsmen & warriors)
+ self.assertEqual(set(['Willie', 'Leonidas']), scotsmen ^ warriors)
# ------------------------------------------------------------------
def test_we_can_query_set_membership(self):
- self.assertEqual(__, 127 in set([127, 0, 0, 1]))
- self.assertEqual(__, 'cow' not in set('apocalypse now'))
+ self.assertEqual(True, 127 in set([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/python2/koans/about_string_manipulation.py b/python2/koans/about_string_manipulation.py
index c395309cc..e2682b965 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())
diff --git a/python2/koans/about_strings.py b/python2/koans/about_strings.py
index abfcf5981..bb5bf2748 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))
diff --git a/python2/koans/about_true_and_false.py b/python2/koans/about_true_and_false.py
index 51a6b537f..f806db2f5 100644
--- a/python2/koans/about_true_and_false.py
+++ b/python2/koans/about_true_and_false.py
@@ -12,31 +12,31 @@ 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(1,))
+ self.assertEqual('true stuff', self.truth_value(1))
+ self.assertEqual('true stuff', self.truth_value(1,))
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/python2/koans/about_tuples.py b/python2/koans/about_tuples.py
index 84ba5d552..9ed82d75f 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(".* 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,7 +25,7 @@ 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(".* no attribute 'append'", ex[0])
# Tuples are less flexible than lists, but faster.
@@ -36,25 +36,28 @@ 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(__, ("Hello comma!", ))
+ self.assertEqual(int, (1).__class__)
+ self.assertEqual(tuple, (1,).__class__)
+ self.assertEqual(("Hello comma!", ), ("Hello comma!", ))
+ # Tuples of one have a length of one
+ self.assertEqual(1, len((1, )))
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 +69,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])
diff --git a/python2/koans/triangle.py b/python2/koans/triangle.py
index 8f3faeed3..8049d7ac7 100644
--- a/python2/koans/triangle.py
+++ b/python2/koans/triangle.py
@@ -18,8 +18,16 @@
# 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, "Values must be greater zero"
+ if a > b + c or b > a + c or c > a +b:
+ raise TriangleError, "One value must not be bigger than " + \
+ "the sum of the others"
+ if a == b == c:
+ return 'equilateral'
+ if a == b or b == c or a == c:
+ return 'isosceles'
+ return 'scalene'
# Error class used in part 2. No need to change this code.