mime-types 1.15 → 1.16
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data.tar.gz.sig +2 -0
- data/{ChangeLog → History.txt} +21 -15
- data/Install.txt +17 -0
- data/{LICENCE → Licence.txt} +0 -3
- data/Manifest.txt +12 -0
- data/README.txt +28 -0
- data/Rakefile +268 -160
- data/lib/mime/types.rb +109 -916
- data/lib/mime/types.rb.data +1324 -0
- data/mime-types.gemspec +43 -0
- data/setup.rb +799 -580
- data/test/test_mime_type.rb +356 -0
- data/test/test_mime_types.rb +122 -0
- metadata +120 -51
- metadata.gz.sig +0 -0
- data/Install +0 -16
- data/README +0 -30
- data/pre-setup.rb +0 -46
- data/tests/tc_mime_type.rb +0 -275
- data/tests/tc_mime_types.rb +0 -77
- data/tests/testall.rb +0 -18
@@ -0,0 +1,356 @@
|
|
1
|
+
#! /usr/bin/env ruby
|
2
|
+
#--
|
3
|
+
# MIME::Types
|
4
|
+
# A Ruby implementation of a MIME Types information library. Based in spirit
|
5
|
+
# on the Perl MIME::Types information library by Mark Overmeer.
|
6
|
+
# http://rubyforge.org/projects/mime-types/
|
7
|
+
#
|
8
|
+
# Licensed under the Ruby disjunctive licence with the GNU GPL or the Perl
|
9
|
+
# Artistic licence. See Licence.txt for more information.
|
10
|
+
#
|
11
|
+
# Copyright 2003 - 2009 Austin Ziegler
|
12
|
+
#++
|
13
|
+
$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
|
14
|
+
|
15
|
+
require 'mime/types'
|
16
|
+
require 'test/unit' unless defined? $ZENTEST and $ZENTEST
|
17
|
+
|
18
|
+
module TestMIME
|
19
|
+
class TestType < Test::Unit::TestCase #:nodoc:
|
20
|
+
def setup
|
21
|
+
@zip = MIME::Type.new('x-appl/x-zip') { |t| t.extensions = ['zip', 'zp'] }
|
22
|
+
end
|
23
|
+
|
24
|
+
def test_class_from_array
|
25
|
+
assert_nothing_raised do
|
26
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit', 'linux')
|
27
|
+
end
|
28
|
+
assert_instance_of(MIME::Type, @yaml)
|
29
|
+
assert_equal('text/yaml', @yaml.simplified)
|
30
|
+
end
|
31
|
+
|
32
|
+
def test_class_from_hash
|
33
|
+
assert_nothing_raised do
|
34
|
+
@yaml = MIME::Type.from_hash('Content-Type' => 'text/x-yaml',
|
35
|
+
'Content-Transfer-Encoding' => '8bit',
|
36
|
+
'System' => 'linux',
|
37
|
+
'Extensions' => %w(yaml yml))
|
38
|
+
end
|
39
|
+
assert_instance_of(MIME::Type, @yaml)
|
40
|
+
assert_equal('text/yaml', @yaml.simplified)
|
41
|
+
end
|
42
|
+
|
43
|
+
def test_class_from_mime_type
|
44
|
+
assert_nothing_raised do
|
45
|
+
@zip2 = MIME::Type.from_mime_type(@zip)
|
46
|
+
end
|
47
|
+
assert_instance_of(MIME::Type, @zip)
|
48
|
+
assert_equal('appl/zip', @zip.simplified)
|
49
|
+
assert_not_equal(@zip.object_id, @zip2.object_id)
|
50
|
+
end
|
51
|
+
|
52
|
+
def test_class_simplified
|
53
|
+
assert_equal(MIME::Type.simplified('text/plain'), 'text/plain')
|
54
|
+
assert_equal(MIME::Type.simplified('image/jpeg'), 'image/jpeg')
|
55
|
+
assert_equal(MIME::Type.simplified('application/x-msword'), 'application/msword')
|
56
|
+
assert_equal(MIME::Type.simplified('text/vCard'), 'text/vcard')
|
57
|
+
assert_equal(MIME::Type.simplified('application/pkcs7-mime'), 'application/pkcs7-mime')
|
58
|
+
assert_equal(@zip.simplified, 'appl/zip')
|
59
|
+
assert_equal(MIME::Type.simplified('x-xyz/abc'), 'xyz/abc')
|
60
|
+
end
|
61
|
+
|
62
|
+
def test_CMP # '<=>'
|
63
|
+
assert(MIME::Type.new('text/plain') == MIME::Type.new('text/plain'))
|
64
|
+
assert(MIME::Type.new('text/plain') != MIME::Type.new('image/jpeg'))
|
65
|
+
assert(MIME::Type.new('text/plain') == 'text/plain')
|
66
|
+
assert(MIME::Type.new('text/plain') != 'image/jpeg')
|
67
|
+
assert(MIME::Type.new('text/plain') > MIME::Type.new('text/html'))
|
68
|
+
assert(MIME::Type.new('text/plain') > 'text/html')
|
69
|
+
assert(MIME::Type.new('text/html') < MIME::Type.new('text/plain'))
|
70
|
+
assert(MIME::Type.new('text/html') < 'text/plain')
|
71
|
+
assert('text/html' == MIME::Type.new('text/html'))
|
72
|
+
assert('text/html' < MIME::Type.new('text/plain'))
|
73
|
+
assert('text/plain' > MIME::Type.new('text/html'))
|
74
|
+
end
|
75
|
+
|
76
|
+
def test_ascii_eh
|
77
|
+
assert(MIME::Type.new('text/plain').ascii?)
|
78
|
+
assert(!MIME::Type.new('image/jpeg').ascii?)
|
79
|
+
assert(!MIME::Type.new('application/x-msword').ascii?)
|
80
|
+
assert(MIME::Type.new('text/vCard').ascii?)
|
81
|
+
assert(!MIME::Type.new('application/pkcs7-mime').ascii?)
|
82
|
+
assert(!@zip.ascii?)
|
83
|
+
end
|
84
|
+
|
85
|
+
def test_binary_eh
|
86
|
+
assert(!MIME::Type.new('text/plain').binary?)
|
87
|
+
assert(MIME::Type.new('image/jpeg').binary?)
|
88
|
+
assert(MIME::Type.new('application/x-msword').binary?)
|
89
|
+
assert(!MIME::Type.new('text/vCard').binary?)
|
90
|
+
assert(MIME::Type.new('application/pkcs7-mime').binary?)
|
91
|
+
assert(@zip.binary?)
|
92
|
+
end
|
93
|
+
|
94
|
+
def test_complete_eh
|
95
|
+
assert_nothing_raised do
|
96
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
|
97
|
+
'linux')
|
98
|
+
end
|
99
|
+
assert(@yaml.complete?)
|
100
|
+
assert_nothing_raised { @yaml.extensions = nil }
|
101
|
+
assert(!@yaml.complete?)
|
102
|
+
end
|
103
|
+
|
104
|
+
def test_content_type
|
105
|
+
assert_equal(MIME::Type.new('text/plain').content_type, 'text/plain')
|
106
|
+
assert_equal(MIME::Type.new('image/jpeg').content_type, 'image/jpeg')
|
107
|
+
assert_equal(MIME::Type.new('application/x-msword').content_type, 'application/x-msword')
|
108
|
+
assert_equal(MIME::Type.new('text/vCard').content_type, 'text/vCard')
|
109
|
+
assert_equal(MIME::Type.new('application/pkcs7-mime').content_type, 'application/pkcs7-mime')
|
110
|
+
assert_equal(@zip.content_type, 'x-appl/x-zip');
|
111
|
+
end
|
112
|
+
|
113
|
+
def test_encoding
|
114
|
+
assert_equal(MIME::Type.new('text/plain').encoding, 'quoted-printable')
|
115
|
+
assert_equal(MIME::Type.new('image/jpeg').encoding, 'base64')
|
116
|
+
assert_equal(MIME::Type.new('application/x-msword').encoding, 'base64')
|
117
|
+
assert_equal(MIME::Type.new('text/vCard').encoding, 'quoted-printable')
|
118
|
+
assert_equal(MIME::Type.new('application/pkcs7-mime').encoding, 'base64')
|
119
|
+
assert_nothing_raised do
|
120
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
|
121
|
+
'linux')
|
122
|
+
end
|
123
|
+
assert_equal(@yaml.encoding, '8bit')
|
124
|
+
assert_nothing_raised { @yaml.encoding = 'base64' }
|
125
|
+
assert_equal(@yaml.encoding, 'base64')
|
126
|
+
assert_nothing_raised { @yaml.encoding = :default }
|
127
|
+
assert_equal(@yaml.encoding, 'quoted-printable')
|
128
|
+
assert_raises(ArgumentError) { @yaml.encoding = 'binary' }
|
129
|
+
assert_equal(@zip.encoding, 'base64')
|
130
|
+
end
|
131
|
+
|
132
|
+
def _test_default_encoding
|
133
|
+
raise NotImplementedError, 'Need to write test_default_encoding'
|
134
|
+
end
|
135
|
+
|
136
|
+
def _test_docs
|
137
|
+
raise NotImplementedError, 'Need to write test_docs'
|
138
|
+
end
|
139
|
+
|
140
|
+
def _test_docs_equals
|
141
|
+
raise NotImplementedError, 'Need to write test_docs_equals'
|
142
|
+
end
|
143
|
+
|
144
|
+
def test_eql?
|
145
|
+
assert(MIME::Type.new('text/plain').eql?(MIME::Type.new('text/plain')))
|
146
|
+
assert(!MIME::Type.new('text/plain').eql?(MIME::Type.new('image/jpeg')))
|
147
|
+
assert(!MIME::Type.new('text/plain').eql?('text/plain'))
|
148
|
+
assert(!MIME::Type.new('text/plain').eql?('image/jpeg'))
|
149
|
+
end
|
150
|
+
|
151
|
+
def _test_encoding
|
152
|
+
raise NotImplementedError, 'Need to write test_encoding'
|
153
|
+
end
|
154
|
+
|
155
|
+
def _test_encoding_equals
|
156
|
+
raise NotImplementedError, 'Need to write test_encoding_equals'
|
157
|
+
end
|
158
|
+
|
159
|
+
def test_extensions
|
160
|
+
assert_nothing_raised do
|
161
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
|
162
|
+
'linux')
|
163
|
+
end
|
164
|
+
assert_equal(@yaml.extensions, %w(yaml yml))
|
165
|
+
assert_nothing_raised { @yaml.extensions = 'yaml' }
|
166
|
+
assert_equal(@yaml.extensions, ['yaml'])
|
167
|
+
assert_equal(@zip.extensions.size, 2)
|
168
|
+
assert_equal(@zip.extensions, ['zip', 'zp'])
|
169
|
+
end
|
170
|
+
|
171
|
+
def _test_extensions_equals
|
172
|
+
raise NotImplementedError, 'Need to write test_extensions_equals'
|
173
|
+
end
|
174
|
+
|
175
|
+
def test_like_eh
|
176
|
+
assert(MIME::Type.new('text/plain').like?(MIME::Type.new('text/plain')))
|
177
|
+
assert(MIME::Type.new('text/plain').like?(MIME::Type.new('text/x-plain')))
|
178
|
+
assert(!MIME::Type.new('text/plain').like?(MIME::Type.new('image/jpeg')))
|
179
|
+
assert(MIME::Type.new('text/plain').like?('text/plain'))
|
180
|
+
assert(MIME::Type.new('text/plain').like?('text/x-plain'))
|
181
|
+
assert(!MIME::Type.new('text/plain').like?('image/jpeg'))
|
182
|
+
end
|
183
|
+
|
184
|
+
def test_media_type
|
185
|
+
assert_equal(MIME::Type.new('text/plain').media_type, 'text')
|
186
|
+
assert_equal(MIME::Type.new('image/jpeg').media_type, 'image')
|
187
|
+
assert_equal(MIME::Type.new('application/x-msword').media_type, 'application')
|
188
|
+
assert_equal(MIME::Type.new('text/vCard').media_type, 'text')
|
189
|
+
assert_equal(MIME::Type.new('application/pkcs7-mime').media_type, 'application')
|
190
|
+
assert_equal(MIME::Type.new('x-chemical/x-pdb').media_type, 'chemical')
|
191
|
+
assert_equal(@zip.media_type, 'appl')
|
192
|
+
end
|
193
|
+
|
194
|
+
def _test_obsolete_eh
|
195
|
+
raise NotImplementedError, 'Need to write test_obsolete_eh'
|
196
|
+
end
|
197
|
+
|
198
|
+
def _test_obsolete_equals
|
199
|
+
raise NotImplementedError, 'Need to write test_obsolete_equals'
|
200
|
+
end
|
201
|
+
|
202
|
+
def test_platform_eh
|
203
|
+
assert_nothing_raised do
|
204
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
|
205
|
+
'oddbox')
|
206
|
+
end
|
207
|
+
assert(!@yaml.platform?)
|
208
|
+
assert_nothing_raised { @yaml.system = nil }
|
209
|
+
assert(!@yaml.platform?)
|
210
|
+
assert_nothing_raised { @yaml.system = /#{RUBY_PLATFORM}/ }
|
211
|
+
assert(@yaml.platform?)
|
212
|
+
end
|
213
|
+
|
214
|
+
def test_raw_media_type
|
215
|
+
assert_equal(MIME::Type.new('text/plain').raw_media_type, 'text')
|
216
|
+
assert_equal(MIME::Type.new('image/jpeg').raw_media_type, 'image')
|
217
|
+
assert_equal(MIME::Type.new('application/x-msword').raw_media_type, 'application')
|
218
|
+
assert_equal(MIME::Type.new('text/vCard').raw_media_type, 'text')
|
219
|
+
assert_equal(MIME::Type.new('application/pkcs7-mime').raw_media_type, 'application')
|
220
|
+
|
221
|
+
assert_equal(MIME::Type.new('x-chemical/x-pdb').raw_media_type, 'x-chemical')
|
222
|
+
assert_equal(@zip.raw_media_type, 'x-appl')
|
223
|
+
end
|
224
|
+
|
225
|
+
def test_raw_sub_type
|
226
|
+
assert_equal(MIME::Type.new('text/plain').raw_sub_type, 'plain')
|
227
|
+
assert_equal(MIME::Type.new('image/jpeg').raw_sub_type, 'jpeg')
|
228
|
+
assert_equal(MIME::Type.new('application/x-msword').raw_sub_type, 'x-msword')
|
229
|
+
assert_equal(MIME::Type.new('text/vCard').raw_sub_type, 'vCard')
|
230
|
+
assert_equal(MIME::Type.new('application/pkcs7-mime').raw_sub_type, 'pkcs7-mime')
|
231
|
+
assert_equal(@zip.raw_sub_type, 'x-zip')
|
232
|
+
end
|
233
|
+
|
234
|
+
def test_registered_eh
|
235
|
+
assert(MIME::Type.new('text/plain').registered?)
|
236
|
+
assert(MIME::Type.new('image/jpeg').registered?)
|
237
|
+
assert(!MIME::Type.new('application/x-msword').registered?)
|
238
|
+
assert(MIME::Type.new('text/vCard').registered?)
|
239
|
+
assert(MIME::Type.new('application/pkcs7-mime').registered?)
|
240
|
+
assert(!@zip.registered?)
|
241
|
+
end
|
242
|
+
|
243
|
+
def _test_registered_equals
|
244
|
+
raise NotImplementedError, 'Need to write test_registered_equals'
|
245
|
+
end
|
246
|
+
|
247
|
+
def test_signature_eh
|
248
|
+
assert(!MIME::Type.new('text/plain').signature?)
|
249
|
+
assert(!MIME::Type.new('image/jpeg').signature?)
|
250
|
+
assert(!MIME::Type.new('application/x-msword').signature?)
|
251
|
+
assert(MIME::Type.new('text/vCard').signature?)
|
252
|
+
assert(MIME::Type.new('application/pkcs7-mime').signature?)
|
253
|
+
end
|
254
|
+
|
255
|
+
def test_simplified
|
256
|
+
assert_equal(MIME::Type.new('text/plain').simplified, 'text/plain')
|
257
|
+
assert_equal(MIME::Type.new('image/jpeg').simplified, 'image/jpeg')
|
258
|
+
assert_equal(MIME::Type.new('application/x-msword').simplified, 'application/msword')
|
259
|
+
assert_equal(MIME::Type.new('text/vCard').simplified, 'text/vcard')
|
260
|
+
assert_equal(MIME::Type.new('application/pkcs7-mime').simplified, 'application/pkcs7-mime')
|
261
|
+
assert_equal(MIME::Type.new('x-chemical/x-pdb').simplified, 'chemical/pdb')
|
262
|
+
end
|
263
|
+
|
264
|
+
def test_sub_type
|
265
|
+
assert_equal(MIME::Type.new('text/plain').sub_type, 'plain')
|
266
|
+
assert_equal(MIME::Type.new('image/jpeg').sub_type, 'jpeg')
|
267
|
+
assert_equal(MIME::Type.new('application/x-msword').sub_type, 'msword')
|
268
|
+
assert_equal(MIME::Type.new('text/vCard').sub_type, 'vcard')
|
269
|
+
assert_equal(MIME::Type.new('application/pkcs7-mime').sub_type, 'pkcs7-mime')
|
270
|
+
assert_equal(@zip.sub_type, 'zip')
|
271
|
+
end
|
272
|
+
|
273
|
+
def test_system_equals
|
274
|
+
assert_nothing_raised do
|
275
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
|
276
|
+
'linux')
|
277
|
+
end
|
278
|
+
assert_equal(@yaml.system, %r{linux})
|
279
|
+
assert_nothing_raised { @yaml.system = /win32/ }
|
280
|
+
assert_equal(@yaml.system, %r{win32})
|
281
|
+
assert_nothing_raised { @yaml.system = nil }
|
282
|
+
assert_nil(@yaml.system)
|
283
|
+
end
|
284
|
+
|
285
|
+
def test_system_eh
|
286
|
+
assert_nothing_raised do
|
287
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
|
288
|
+
'linux')
|
289
|
+
end
|
290
|
+
assert(@yaml.system?)
|
291
|
+
assert_nothing_raised { @yaml.system = nil }
|
292
|
+
assert(!@yaml.system?)
|
293
|
+
end
|
294
|
+
|
295
|
+
def test_to_a
|
296
|
+
assert_nothing_raised do
|
297
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
|
298
|
+
'linux')
|
299
|
+
end
|
300
|
+
assert_equal(@yaml.to_a, ['text/x-yaml', %w(yaml yml), '8bit',
|
301
|
+
/linux/, nil, nil, nil, false])
|
302
|
+
end
|
303
|
+
|
304
|
+
def test_to_hash
|
305
|
+
assert_nothing_raised do
|
306
|
+
@yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
|
307
|
+
'linux')
|
308
|
+
end
|
309
|
+
assert_equal(@yaml.to_hash,
|
310
|
+
{ 'Content-Type' => 'text/x-yaml',
|
311
|
+
'Content-Transfer-Encoding' => '8bit',
|
312
|
+
'Extensions' => %w(yaml yml),
|
313
|
+
'System' => /linux/,
|
314
|
+
'Registered' => false,
|
315
|
+
'URL' => nil,
|
316
|
+
'Obsolete' => nil,
|
317
|
+
'Docs' => nil })
|
318
|
+
end
|
319
|
+
|
320
|
+
def test_to_s
|
321
|
+
assert_equal("#{MIME::Type.new('text/plain')}", 'text/plain')
|
322
|
+
end
|
323
|
+
|
324
|
+
def test_class_constructors
|
325
|
+
assert_not_nil(@zip)
|
326
|
+
yaml = MIME::Type.new('text/x-yaml') do |y|
|
327
|
+
y.extensions = %w(yaml yml)
|
328
|
+
y.encoding = '8bit'
|
329
|
+
y.system = 'linux'
|
330
|
+
end
|
331
|
+
assert_instance_of(MIME::Type, yaml)
|
332
|
+
assert_raises(MIME::InvalidContentType) { MIME::Type.new('apps') }
|
333
|
+
assert_raises(MIME::InvalidContentType) { MIME::Type.new(nil) }
|
334
|
+
end
|
335
|
+
|
336
|
+
def _test_to_str
|
337
|
+
raise NotImplementedError, 'Need to write test_to_str'
|
338
|
+
end
|
339
|
+
|
340
|
+
def _test_url
|
341
|
+
raise NotImplementedError, 'Need to write test_url'
|
342
|
+
end
|
343
|
+
|
344
|
+
def _test_url_equals
|
345
|
+
raise NotImplementedError, 'Need to write test_url_equals'
|
346
|
+
end
|
347
|
+
|
348
|
+
def _test_urls
|
349
|
+
raise NotImplementedError, 'Need to write test_urls'
|
350
|
+
end
|
351
|
+
|
352
|
+
def __test_use_instead
|
353
|
+
raise NotImplementedError, 'Need to write test_use_instead'
|
354
|
+
end
|
355
|
+
end
|
356
|
+
end
|
@@ -0,0 +1,122 @@
|
|
1
|
+
#! /usr/bin/env ruby
|
2
|
+
#--
|
3
|
+
# MIME::Types
|
4
|
+
# A Ruby implementation of a MIME Types information library. Based in spirit
|
5
|
+
# on the Perl MIME::Types information library by Mark Overmeer.
|
6
|
+
# http://rubyforge.org/projects/mime-types/
|
7
|
+
#
|
8
|
+
# Licensed under the Ruby disjunctive licence with the GNU GPL or the Perl
|
9
|
+
# Artistic licence. See Licence.txt for more information.
|
10
|
+
#
|
11
|
+
# Copyright 2003 - 2009 Austin Ziegler
|
12
|
+
#++
|
13
|
+
$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
|
14
|
+
|
15
|
+
require 'mime/types'
|
16
|
+
require 'test/unit' unless defined? $ZENTEST and $ZENTEST
|
17
|
+
|
18
|
+
module TestMIME
|
19
|
+
class TestTypes < Test::Unit::TestCase #:nodoc:
|
20
|
+
def test_class_index_1
|
21
|
+
text_plain = MIME::Type.new('text/plain') do |t|
|
22
|
+
t.encoding = '8bit'
|
23
|
+
t.extensions = %w(asc txt c cc h hh cpp hpp dat hlp)
|
24
|
+
end
|
25
|
+
text_plain_vms = MIME::Type.new('text/plain') do |t|
|
26
|
+
t.encoding = '8bit'
|
27
|
+
t.extensions = %w(doc)
|
28
|
+
t.system = 'vms'
|
29
|
+
end
|
30
|
+
|
31
|
+
assert_equal(MIME::Types['text/plain'], [text_plain, text_plain_vms])
|
32
|
+
end
|
33
|
+
|
34
|
+
def test_class_index_2
|
35
|
+
tst_bmp = MIME::Types["image/x-bmp"] +
|
36
|
+
MIME::Types["image/vnd.wap.wbmp"] + MIME::Types["image/x-win-bmp"]
|
37
|
+
|
38
|
+
assert_equal(tst_bmp.sort, MIME::Types[/bmp$/].sort)
|
39
|
+
|
40
|
+
assert_nothing_raised {
|
41
|
+
MIME::Types['image/bmp'][0].system = RUBY_PLATFORM
|
42
|
+
}
|
43
|
+
|
44
|
+
assert_equal([MIME::Type.from_array('image/x-bmp', ['bmp'])],
|
45
|
+
MIME::Types[/bmp$/, { :platform => true }])
|
46
|
+
end
|
47
|
+
|
48
|
+
def test_class_index_3
|
49
|
+
assert(MIME::Types['text/vnd.fly', { :complete => true }].empty?)
|
50
|
+
assert(!MIME::Types['text/plain', { :complete => true} ].empty?)
|
51
|
+
end
|
52
|
+
|
53
|
+
def _test_class_index_extensions
|
54
|
+
raise NotImplementedError, 'Need to write test_class_index_extensions'
|
55
|
+
end
|
56
|
+
|
57
|
+
def _test_class_add
|
58
|
+
assert_nothing_raised do
|
59
|
+
@eruby = MIME::Type.new("application/x-eruby") do |t|
|
60
|
+
t.extensions = "rhtml"
|
61
|
+
t.encoding = "8bit"
|
62
|
+
end
|
63
|
+
|
64
|
+
MIME::Types.add(@eruby)
|
65
|
+
end
|
66
|
+
|
67
|
+
assert_equal(MIME::Types['application/x-eruby'], [@eruby])
|
68
|
+
end
|
69
|
+
|
70
|
+
def _test_class_add_type_variant
|
71
|
+
raise NotImplementedError, 'Need to write test_class_add_type_variant'
|
72
|
+
end
|
73
|
+
|
74
|
+
def test_class_type_for
|
75
|
+
assert_equal(MIME::Types.type_for('xml').sort, [ MIME::Types['text/xml'], MIME::Types['application/xml'] ].sort)
|
76
|
+
assert_equal(MIME::Types.type_for('gif'), MIME::Types['image/gif'])
|
77
|
+
assert_nothing_raised do
|
78
|
+
MIME::Types['image/gif'][0].system = RUBY_PLATFORM
|
79
|
+
end
|
80
|
+
assert_equal(MIME::Types.type_for('gif', true), MIME::Types['image/gif'])
|
81
|
+
assert(MIME::Types.type_for('zzz').empty?)
|
82
|
+
end
|
83
|
+
|
84
|
+
def test_class_of
|
85
|
+
assert_equal(MIME::Types.of('xml').sort, [ MIME::Types['text/xml'], MIME::Types['application/xml'] ].sort)
|
86
|
+
assert_equal(MIME::Types.of('gif'), MIME::Types['image/gif'])
|
87
|
+
assert_nothing_raised do
|
88
|
+
MIME::Types['image/gif'][0].system = RUBY_PLATFORM
|
89
|
+
end
|
90
|
+
assert_equal(MIME::Types.of('gif', true), MIME::Types['image/gif'])
|
91
|
+
assert(MIME::Types.of('zzz').empty?)
|
92
|
+
end
|
93
|
+
|
94
|
+
def _test_add
|
95
|
+
raise NotImplementedError, 'Need to write test_add'
|
96
|
+
end
|
97
|
+
|
98
|
+
def _test_add_type_variant
|
99
|
+
raise NotImplementedError, 'Need to write test_add_type_variant'
|
100
|
+
end
|
101
|
+
|
102
|
+
def _test_data_version
|
103
|
+
raise NotImplementedError, 'Need to write test_data_version'
|
104
|
+
end
|
105
|
+
|
106
|
+
def _test_index
|
107
|
+
raise NotImplementedError, 'Need to write test_index'
|
108
|
+
end
|
109
|
+
|
110
|
+
def _test_index_extensions
|
111
|
+
raise NotImplementedError, 'Need to write test_index_extensions'
|
112
|
+
end
|
113
|
+
|
114
|
+
def _test_of
|
115
|
+
raise NotImplementedError, 'Need to write test_of'
|
116
|
+
end
|
117
|
+
|
118
|
+
def _test_type_for
|
119
|
+
raise NotImplementedError, 'Need to write test_type_for'
|
120
|
+
end
|
121
|
+
end
|
122
|
+
end
|