FilesExpand file tree

 python2.5

/

about_classes.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

158 lines (109 loc) · 4.78 KB

 python2.5

/

about_classes.py

Copy path

Top

File metadata and controls

• Code
• Blame

158 lines (109 loc) · 4.78 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

#!/usr/bin/env python

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

from runner.koan import *

class AboutClasses(Koan):

class Dog(object):

"Dogs need regular walkies. Never, ever let them drive."

def test_instances_of_classes_can_be_created_adding_parenthesis(self):

fido = self.Dog()

self.assertEqual(__, type(fido).__name__)

def test_classes_have_docstrings(self):

self.assertMatch(__, self.Dog.__doc__)

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

class Dog2(object):

def __init__(self):

self._name = 'Paul'

def set_name(self, a_name):

self._name = a_name

def test_init_method_is_the_constructor(self):

dog = self.Dog2()

self.assertEqual(__, dog._name)

def test_private_attributes_are_not_really_private(self):

dog = self.Dog2()

dog.set_name("Fido")

self.assertEqual(__, dog._name)

# The _ prefix in _name implies private ownership, but nothing is truly

# private in Python.

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

# getattr(), setattr() and delattr() are a way of accessing attributes

# by method rather than through assignment operators

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

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

class Dog3(object):

def __init__(self):

self._name = None

def set_name(self, a_name):

self._name = a_name

def get_name(self):

return self._name

name = property(get_name, set_name)

def test_that_name_can_be_read_as_a_property(self):

fido = self.Dog3()

fido.set_name("Fido")

self.assertEqual(__, fido.get_name()) # access as method

self.assertEqual(__, fido.name) # access as property

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

class Dog4(object):

def __init__(self):

self._name = None

@property

def name(self):

return self._name

def set_name(self, a_name):

self._name = a_name

def test_accessing_properties_with_decorators(self):

fido = self.Dog4()

fido.set_name("Fido")

self.assertEqual(__, fido.name)

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

class Dog5(object):

def __init__(self, initial_name):

self._name = initial_name

@property

def name(self):

return self._name

def test_init_provides_initial_values_for_instance_variables(self):

fido = self.Dog5("Fido")

self.assertEqual(__, fido.name)

def test_args_must_match_init(self):

self.assertRaises(___, self.Dog5) # Evaluates self.Dog5()

# THINK ABOUT IT:

# Why is this so?

def test_different_objects_have_difference_instance_variables(self):

fido = self.Dog5("Fido")

rover = self.Dog5("Rover")

self.assertEqual(____, rover.name == fido.name)

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

class Dog6(object):

def __init__(self, initial_name):

self._name = initial_name

def get_self(self):

return self

def __str__(self):

return __

def __repr__(self):

return "<Dog named '" + self._name + "'>"

def test_inside_a_method_self_refers_to_the_containing_object(self):

fido = self.Dog6("Fido")

self.assertEqual(__, fido.get_self()) # Not a string!

def test_str_provides_a_string_version_of_the_object(self):

fido = self.Dog6("Fido")

self.assertEqual("Bob", str(fido))

def test_str_is_used_explicitly_in_string_interpolation(self):

fido = self.Dog6("Fido")

self.assertEqual(__, "My dog is " + str(fido))

def test_repr_provides_a_more_complete_string_version(self):

fido = self.Dog6("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(__, str("STRING"))

self.assertEqual(__, repr("STRING"))