FilesExpand file tree

 master

/

about_methods.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

162 lines (112 loc) · 5.18 KB

 master

/

about_methods.py

Copy path

Top

File metadata and controls

• Code
• Blame

162 lines (112 loc) · 5.18 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

# Partially based on AboutMethods in the Ruby Koans

#

from runner.koan import *

def my_global_function(a,b):

return a + b

class AboutMethods(Koan):

def test_calling_a_global_function(self):

self.assertEqual(__, my_global_function(2,3))

# NOTE: Wrong number of arguments is not a SYNTAX error, but a

# runtime error.

def test_calling_functions_with_wrong_number_of_arguments(self):

try:

my_global_function()

except TypeError as exception:

msg = exception.args[0]

self.assertRegexpMatches(msg,

r'my_global_function\(\) takes exactly 2 ' +

r'arguments \(0 given\)')

try:

my_global_function(1, 2, 3)

except Exception as e:

msg = e.args[0]

# Note, watch out for parenthesis. They need slashes in front!

self.assertRegexpMatches(msg, __)

# ------------------------------------------------------------------

def pointless_method(self, a, b):

sum = a + b

def test_which_does_not_return_anything(self):

self.assertEqual(__, self.pointless_method(1, 2))

# Notice that methods accessed from class scope do not require

# you to pass the first "self" argument?

# ------------------------------------------------------------------

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))

# ------------------------------------------------------------------

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(('one',), self.method_with_var_args('one'))

self.assertEqual(__, self.method_with_var_args('one', 'two'))

# ------------------------------------------------------------------

def function_with_the_same_name(self, a, b):

return a + b

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))

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))

# ------------------------------------------------------------------

def another_method_with_the_same_name(self):

return 10

link_to_overlapped_method = another_method_with_the_same_name

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())

def test_that_overlapped_method_is_still_there(self):

self.assertEqual(__, self.link_to_overlapped_method())

# ------------------------------------------------------------------

def empty_method(self):

pass

def test_methods_that_do_nothing_need_to_use_pass_as_a_filler(self):

self.assertEqual(__, self.empty_method())

def test_pass_does_nothing_at_all(self):

"You"

"shall"

"not"

pass

self.assertEqual(____, "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())

# ------------------------------------------------------------------

def method_with_documentation(self):

"A string placed at the beginning of a function is used for documentation"

return "ok"

def test_the_documentation_can_be_viewed_with_the_doc_method(self):

self.assertRegexpMatches(self.method_with_documentation.__doc__, __)

# ------------------------------------------------------------------

class Dog:

def name(self):

return "Fido"

def _tail(self):

# Prefixing a method with an underscore implies private scope

return "wagging"

def __password(self):

return 'password' # Genius!

def test_calling_methods_in_other_objects(self):

rover = self.Dog()

self.assertEqual(__, 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())

def test_attributes_with_double_underscore_prefixes_are_subject_to_name_mangling(self):

rover = self.Dog()

with self.assertRaises(___): password = rover.__password()

# But this still is!

self.assertEqual(__, rover._Dog__password())

# Name mangling exists to avoid name clash issues when subclassing.

# It is not for providing effective access protection