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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
# encoding: utf-8
require 'date'
require 'abstract_unit'
require 'inflector_test_cases'
class StringInflectionsTest < Test::Unit::TestCase
include InflectorTestCases
def test_pluralize
SingularToPlural.each do |singular, plural|
assert_equal(plural, singular.pluralize)
end
assert_equal("plurals", "plurals".pluralize)
end
def test_singularize
SingularToPlural.each do |singular, plural|
assert_equal(singular, plural.singularize)
end
end
def test_titleize
MixtureToTitleCase.each do |before, titleized|
assert_equal(titleized, before.titleize)
end
end
def test_camelize
CamelToUnderscore.each do |camel, underscore|
assert_equal(camel, underscore.camelize)
end
end
def test_camelize_lower
assert_equal('capital', 'Capital'.camelize(:lower))
end
def test_underscore
CamelToUnderscore.each do |camel, underscore|
assert_equal(underscore, camel.underscore)
end
assert_equal "html_tidy", "HTMLTidy".underscore
assert_equal "html_tidy_generator", "HTMLTidyGenerator".underscore
end
def test_underscore_to_lower_camel
UnderscoreToLowerCamel.each do |underscored, lower_camel|
assert_equal(lower_camel, underscored.camelize(:lower))
end
end
def test_demodulize
assert_equal "Account", "MyApplication::Billing::Account".demodulize
end
def test_foreign_key
ClassNameToForeignKeyWithUnderscore.each do |klass, foreign_key|
assert_equal(foreign_key, klass.foreign_key)
end
ClassNameToForeignKeyWithoutUnderscore.each do |klass, foreign_key|
assert_equal(foreign_key, klass.foreign_key(false))
end
end
def test_tableize
ClassNameToTableName.each do |class_name, table_name|
assert_equal(table_name, class_name.tableize)
end
end
def test_classify
ClassNameToTableName.each do |class_name, table_name|
assert_equal(class_name, table_name.classify)
end
end
def test_humanize
UnderscoreToHuman.each do |underscore, human|
assert_equal(human, underscore.humanize)
end
end
def test_ord
assert_equal 97, 'a'.ord
assert_equal 97, 'abc'.ord
end
def test_string_to_time
assert_equal Time.utc(2005, 2, 27, 23, 50), "2005-02-27 23:50".to_time
assert_equal Time.local(2005, 2, 27, 23, 50), "2005-02-27 23:50".to_time(:local)
assert_equal DateTime.civil(2039, 2, 27, 23, 50), "2039-02-27 23:50".to_time
assert_equal Time.local_time(2039, 2, 27, 23, 50), "2039-02-27 23:50".to_time(:local)
end
def test_string_to_datetime
assert_equal DateTime.civil(2039, 2, 27, 23, 50), "2039-02-27 23:50".to_datetime
assert_equal 0, "2039-02-27 23:50".to_datetime.offset # use UTC offset
assert_equal ::Date::ITALY, "2039-02-27 23:50".to_datetime.start # use Ruby's default start value
end
def test_string_to_date
assert_equal Date.new(2005, 2, 27), "2005-02-27".to_date
end
def test_access
s = "hello"
assert_equal "h", s.at(0)
assert_equal "llo", s.from(2)
assert_equal "hel", s.to(2)
assert_equal "h", s.first
assert_equal "he", s.first(2)
assert_equal "o", s.last
assert_equal "llo", s.last(3)
assert_equal "hello", s.last(10)
assert_equal 'x', 'x'.first
assert_equal 'x', 'x'.first(4)
assert_equal 'x', 'x'.last
assert_equal 'x', 'x'.last(4)
end
def test_access_returns_a_real_string
hash = {}
hash["h"] = true
hash["hello123".at(0)] = true
assert_equal %w(h), hash.keys
hash = {}
hash["llo"] = true
hash["hello".from(2)] = true
assert_equal %w(llo), hash.keys
hash = {}
hash["hel"] = true
hash["hello".to(2)] = true
assert_equal %w(hel), hash.keys
hash = {}
hash["hello"] = true
hash["123hello".last(5)] = true
assert_equal %w(hello), hash.keys
hash = {}
hash["hello"] = true
hash["hello123".first(5)] = true
assert_equal %w(hello), hash.keys
end
def test_starts_ends_with_alias
s = "hello"
assert s.starts_with?('h')
assert s.starts_with?('hel')
assert !s.starts_with?('el')
assert s.start_with?('h')
assert s.start_with?('hel')
assert !s.start_with?('el')
assert s.ends_with?('o')
assert s.ends_with?('lo')
assert !s.ends_with?('el')
assert s.end_with?('o')
assert s.end_with?('lo')
assert !s.end_with?('el')
end
def test_string_squish
original = %{ A string with tabs(\t\t), newlines(\n\n), and
many spaces( ). }
expected = "A string with tabs( ), newlines( ), and many spaces( )."
# Make sure squish returns what we expect:
assert_equal original.squish, expected
# But doesn't modify the original string:
assert_not_equal original, expected
# Make sure squish! returns what we expect:
assert_equal original.squish!, expected
# And changes the original string:
assert_equal original, expected
end
if RUBY_VERSION < '1.9'
def test_each_char_with_utf8_string_when_kcode_is_utf8
old_kcode, $KCODE = $KCODE, 'UTF8'
'€2.99'.each_char do |char|
assert_not_equal 1, char.length
break
end
ensure
$KCODE = old_kcode
end
end
end
class StringBehaviourTest < Test::Unit::TestCase
def test_acts_like_string
assert 'Bambi'.acts_like_string?
end
end
|
