FilesExpand file tree

 python2.5

/

about_strings.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

146 lines (112 loc) · 4.87 KB

 python2.5

/

about_strings.py

Copy path

Top

File metadata and controls

• Code
• Blame

146 lines (112 loc) · 4.87 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

#!/usr/bin/env python

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

from runner.koan import *

class AboutStrings(Koan):

def test_double_quoted_strings_are_strings(self):

string = "Hello, world."

self.assertEqual(__, isinstance(string, str))

def test_single_quoted_strings_are_also_strings(self):

string = 'Goodbye, world.'

self.assertEqual(__, isinstance(string, str))

def test_triple_quote_strings_are_also_strings(self):

string = """Howdy, world!"""

self.assertEqual(__, isinstance(string, str))

def test_triple_single_quotes_work_too(self):

string = '''Bonjour tout le monde!'''

self.assertEqual(__, isinstance(string, str))

def test_use_single_quotes_to_create_string_with_double_quotes(self):

string = 'He said, "Go Away."'

self.assertEqual(__, string)

def test_use_double_quotes_to_create_strings_with_single_quotes(self):

string = "Don't"

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

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

def test_triple_quoted_strings_can_span_lines(self):

string = """

Howdy,

world!

"""

self.assertEqual(__, len(string))

def test_triple_quoted_strings_need_less_escaping(self):

a = "Hello \"world\"."

b = """Hello "world"."""

self.assertEqual(__, (a == b))

def but_you_still_have_to_be_careful_at_the_end_of_a_triple_quoted_string(self):

string = """Hello "world\""""

def test_plus_concatenates_strings(self):

string = "Hello, " + "world"

self.assertEqual(__, string)

def test_plus_will_not_modify_original_strings(self):

hi = "Hello, "

there = "world"

string = hi + there

self.assertEqual(__, hi)

self.assertEqual(__, there)

def test_plus_equals_will_append_to_end_of_string(self):

hi = "Hello, "

there = "world"

hi += there

self.assertEqual(__, hi)

def test_plus_equals_also_leaves_original_string_unmodified(self):

original = "Hello, "

hi = original

there = "world"

hi += there

self.assertEqual(__, original)

def test_most_strings_interpret_escape_characters(self):

string = "\n"

self.assertEqual('\n', string)

self.assertEqual("""\n""", string)

self.assertEqual(__, len(string))

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)

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

def test_any_python_expression_may_be_interpolated(self):

import math # import a standard python module with math functions

decimal_places = 4

string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5), \

decimal_places)

self.assertEqual(__, string)

def test_you_can_get_a_substring_from_a_string(self):

string = "Bacon, lettuce and tomato"

self.assertEqual(__, string[7:10])

def test_you_can_get_a_single_character_from_a_string(self):

string = "Bacon, lettuce and tomato"

self.assertEqual(__, string[1])

def test_single_characters_can_be_represented_by_integers(self):

self.assertEqual(__, ord('a'))

self.assertEqual(__, ord('b') == (ord('a') + 1))

def test_strings_can_be_split(self):

string = "Sausage Egg Cheese"

words = string.split()

self.assertListEqual([__, __, __], words)

def test_strings_can_be_split_with_different_patterns(self):

import re #import python regular expression library

string = "the,rain;in,spain"

pattern = re.compile(r',|;')

words = pattern.split(string)

self.assertListEqual([__, __, __, __], words)

# Pattern is a Python regular expression pattern which matches ',' or ';'

def test_regular_expression_strings_do_not_interpret_escape_characters(self):

string = r'\n'

self.assertNotEqual('\n', string)

self.assertEqual(__, string)

self.assertEqual(__, len(string))

# This is to make patterns easier to read

def test_strings_can_be_joined(self):

words = ["Now", "is", "the", "time"]

self.assertEqual(__, ' '.join(words))