libxml-ruby 2.7.0 → 2.8.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,9 +0,0 @@
1
- require './test_helper'
2
-
3
- 1000000.times do
4
- doc = XML::Document.string('<foo><bar/><baz/></foo>')
5
- #puts doc.root
6
- node = doc.root.first.remove!
7
- doc.root.last.next = node
8
- node = nil
9
- end
@@ -1,86 +0,0 @@
1
- # encoding: UTF-8
2
- require './test_helper'
3
- require 'test/unit'
4
-
5
- class TestFoo < Test::Unit::TestCase
6
- def namespaces
7
- {'kml' => 'http://earth.google.com/kml/2.2'}
8
- end
9
-
10
- def doc
11
- path = File.expand_path(File.join('model', 'kml_sample.xml'))
12
- data = File.read(path)
13
- parser = LibXML::XML::Parser.string(data)
14
- doc = parser.parse
15
- result = doc.root
16
- doc = nil
17
- GC.start
18
- end
19
-
20
- def test_read
21
- 1000.times do
22
- read_placemarks
23
- GC.start
24
- end
25
- end
26
-
27
- def read_placemarks
28
- root = doc.root
29
- result = Array.new
30
- root.find('//kml:Placemark', self.namespaces).each do |entry|
31
- result << self.read_placemark(entry)
32
- end
33
- result
34
- end
35
-
36
- def read_placemark(entry)
37
- geometries = read_geoms(entry)
38
- #stop processing this placemark if there aren't any geometries.
39
- return if geometries.empty?
40
- end
41
-
42
- def read_geoms(entry)
43
-
44
- geoms = []
45
- entry.find('//kml:Point', self.namespaces).each do |point_entry|
46
- geoms << parse_point(point_entry)
47
- end
48
-
49
- entry.find('//kml:LineString', self.namespaces).each do |point_entry|
50
- geoms << parse_point(point_entry)
51
- end
52
-
53
- entry.find('//kml:Polygon', self.namespaces).each do |point_entry|
54
- geoms << parse_polygon(point_entry)
55
- end
56
-
57
- geoms
58
- end
59
-
60
- def parse_point(entry)
61
- coordinate_entry = entry.find('//kml:coordinates',self.namespaces).first
62
- coordinate_entry.content.split(",")
63
- end
64
-
65
- def parse_coordinate_string(entry)
66
- coordinates = entry.content.split
67
- end
68
-
69
- def parse_line_string(entry)
70
- coord_sequence = parse_coordinate_string(entry.find('kml:coordinates',self.namespaces).first)
71
- end
72
-
73
- def parse_linear_ring(entry)
74
- coord_sequence = parse_coordinate_string(entry.find('kml:coordinates',self.namespaces).first)
75
- end
76
-
77
- def parse_polygon(entry)
78
- exterior_ring = parse_linear_ring(entry.find('kml:outerBoundaryIs/kml:LinearRing', self.namespaces).first)
79
-
80
- interior_rings = []
81
- entry.find('kml:innerBoundaryIs/kml:LinearRing', self.namespaces).each do |interior_ring|
82
- interior_rings << parse_linear_ring(interior_ring)
83
- end
84
- interior_rings
85
- end
86
- end
@@ -1,384 +0,0 @@
1
- # encoding: UTF-8
2
-
3
- require './test_helper'
4
- require 'test/unit'
5
- require 'stringio'
6
-
7
- class TestParser < Test::Unit::TestCase
8
- def setup
9
- XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
10
- end
11
-
12
- def teardown
13
- GC.start
14
- GC.start
15
- GC.start
16
- end
17
-
18
- # ----- Sources -------
19
- def test_document
20
- file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
21
- parser = XML::Parser.file(file)
22
- doc = parser.parse
23
-
24
- parser = XML::Parser.document(doc)
25
-
26
- doc = parser.parse
27
-
28
- assert_instance_of(XML::Document, doc)
29
- assert_instance_of(XML::Parser::Context, parser.context)
30
- end
31
-
32
- def test_nil_document
33
- error = assert_raise(TypeError) do
34
- XML::Parser.document(nil)
35
- end
36
-
37
- assert_equal("Must pass an XML::Document object", error.to_s)
38
- end
39
-
40
- def test_file
41
- file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
42
-
43
- parser = XML::Parser.file(file)
44
- doc = parser.parse
45
- assert_instance_of(XML::Document, doc)
46
- assert_instance_of(XML::Parser::Context, parser.context)
47
- end
48
-
49
- def test_noexistent_file
50
- error = assert_raise(XML::Error) do
51
- XML::Parser.file('i_dont_exist.xml')
52
- end
53
-
54
- assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
55
- end
56
-
57
- def test_nil_file
58
- error = assert_raise(TypeError) do
59
- XML::Parser.file(nil)
60
- end
61
-
62
- assert_match(/nil into String/, error.to_s)
63
- end
64
-
65
- def test_file_encoding
66
- file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
67
- parser = XML::Parser.file(file, :encoding => XML::Encoding::ISO_8859_1)
68
-
69
- error = assert_raise(XML::Error) do
70
- doc = parser.parse
71
- end
72
-
73
- assert(error.to_s.match(/Fatal error: Extra content at the end of the document/))
74
-
75
- parser = XML::Parser.file(file, :encoding => XML::Encoding::UTF_8)
76
- doc = parser.parse
77
- assert_not_nil(doc)
78
- end
79
-
80
- def test_file_base_uri
81
- file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
82
-
83
- parser = XML::Parser.file(file)
84
- doc = parser.parse
85
- assert(doc.child.base_uri.match(/test\/model\/bands.utf-8.xml/))
86
-
87
- parser = XML::Parser.file(file, :base_uri => "http://libxml.org")
88
- doc = parser.parse
89
- assert(doc.child.base_uri.match(/test\/model\/bands.utf-8.xml/))
90
- end
91
-
92
- def test_io
93
- File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
94
- parser = XML::Parser.io(io)
95
- assert_instance_of(XML::Parser, parser)
96
-
97
- doc = parser.parse
98
- assert_instance_of(XML::Document, doc)
99
- assert_instance_of(XML::Parser::Context, parser.context)
100
- end
101
- end
102
-
103
- def test_io_gc
104
- # Test that the reader keeps a reference
105
- # to the io object
106
- file = File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
107
- parser = XML::Parser.io(file)
108
- file = nil
109
- GC.start
110
- assert(parser.parse)
111
- end
112
-
113
- def test_nil_io
114
- error = assert_raise(TypeError) do
115
- XML::Parser.io(nil)
116
- end
117
-
118
- assert_equal("Must pass in an IO object", error.to_s)
119
- end
120
-
121
- def test_string_io
122
- data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
123
- string_io = StringIO.new(data)
124
- parser = XML::Parser.io(string_io)
125
-
126
- doc = parser.parse
127
- assert_instance_of(XML::Document, doc)
128
- assert_instance_of(XML::Parser::Context, parser.context)
129
- end
130
-
131
- def test_string_io_thread
132
- thread = Thread.new do
133
- data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
134
- string_io = StringIO.new(data)
135
- parser = XML::Parser.io(string_io)
136
-
137
- doc = parser.parse
138
- assert_instance_of(XML::Document, doc)
139
- assert_instance_of(XML::Parser::Context, parser.context)
140
- end
141
-
142
- thread.join
143
- assert(true)
144
- end
145
-
146
- def test_string
147
- str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
148
-
149
- parser = XML::Parser.string(str)
150
- assert_instance_of(XML::Parser, parser)
151
-
152
- doc = parser.parse
153
- assert_instance_of(XML::Document, doc)
154
- assert_instance_of(XML::Parser::Context, parser.context)
155
- end
156
-
157
- def test_nil_string
158
- error = assert_raise(TypeError) do
159
- XML::Parser.string(nil)
160
- end
161
-
162
- assert_equal("wrong argument type nil (expected String)", error.to_s)
163
- end
164
-
165
- def test_string_options
166
- xml = <<-EOS
167
- <!DOCTYPE foo [<!ENTITY foo 'bar'>]>
168
- <test>
169
- <cdata><![CDATA[something]]></cdata>
170
- <entity>&foo;</entity>
171
- </test>
172
- EOS
173
-
174
- XML::default_substitute_entities = false
175
-
176
- # Parse normally
177
- parser = XML::Parser.string(xml)
178
- doc = parser.parse
179
- assert_nil(doc.child.base_uri)
180
-
181
- # Cdata section should be cdata nodes
182
- node = doc.find_first('/test/cdata').child
183
- assert_equal(XML::Node::CDATA_SECTION_NODE, node.node_type)
184
-
185
- # Entities should not be subtituted
186
- node = doc.find_first('/test/entity')
187
- assert_equal('&foo;', node.child.to_s)
188
-
189
- # Parse with options
190
- parser = XML::Parser.string(xml, :base_uri => 'http://libxml.rubyforge.org',
191
- :options => XML::Parser::Options::NOCDATA | XML::Parser::Options::NOENT)
192
- doc = parser.parse
193
- assert_equal(doc.child.base_uri, 'http://libxml.rubyforge.org')
194
-
195
- # Cdata section should be text nodes
196
- node = doc.find_first('/test/cdata').child
197
- assert_equal(XML::Node::TEXT_NODE, node.node_type)
198
-
199
- # Entities should be subtituted
200
- node = doc.find_first('/test/entity')
201
- assert_equal('bar', node.child.to_s)
202
- end
203
-
204
- def test_string_encoding
205
- # ISO_8859_1:
206
- # ö - f6 in hex, \366 in octal
207
- # ü - fc in hex, \374 in octal
208
-
209
- xml = <<-EOS
210
- <bands>
211
- <metal>m\366tley_cr\374e</metal>
212
- </bands>
213
- EOS
214
-
215
- # Parse as UTF_8
216
- parser = XML::Parser.string(xml, :encoding => XML::Encoding::UTF_8)
217
-
218
- error = assert_raise(XML::Error) do
219
- doc = parser.parse
220
- end
221
-
222
- assert_equal("Fatal error: Input is not proper UTF-8, indicate encoding !\nBytes: 0xF6 0x74 0x6C 0x65 at :2.",
223
- error.to_s)
224
-
225
- # Parse as ISO_8859_1:
226
- parser = XML::Parser.string(xml, :encoding => XML::Encoding::ISO_8859_1)
227
- doc = parser.parse
228
- node = doc.find_first('//metal')
229
- if defined?(Encoding)
230
- assert_equal(Encoding::UTF_8, node.content.encoding)
231
- assert_equal("m\303\266tley_cr\303\274e", node.content)
232
- else
233
- assert_equal("m\303\266tley_cr\303\274e", node.content)
234
- end
235
- end
236
-
237
- def test_fd_gc
238
- # Test opening # of documents up to the file limit for the OS.
239
- # Ideally it should run until libxml emits a warning,
240
- # thereby knowing we've done a GC sweep. For the time being,
241
- # re-open the same doc `limit descriptors` times.
242
- # If we make it to the end, then we've succeeded,
243
- # otherwise an exception will be thrown.
244
- XML::Error.set_handler {|error|}
245
-
246
- max_fd = if RUBY_PLATFORM.match(/mswin32|mingw/i)
247
- 500
248
- else
249
- (`ulimit -n`.chomp.to_i) + 1
250
- end
251
-
252
- file = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
253
- max_fd.times do
254
- XML::Parser.file(file).parse
255
- end
256
- XML::Error.reset_handler {|error|}
257
- end
258
-
259
- def test_open_many_files
260
- 1000.times do
261
- doc = XML::Parser.file('model/atom.xml').parse
262
- end
263
- end
264
-
265
- # ----- Errors ------
266
- def test_error
267
- error = assert_raise(XML::Error) do
268
- XML::Parser.string('<foo><bar/></foz>').parse
269
- end
270
-
271
- assert_not_nil(error)
272
- assert_kind_of(XML::Error, error)
273
- assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", error.message)
274
- assert_equal(XML::Error::PARSER, error.domain)
275
- assert_equal(XML::Error::TAG_NAME_MISMATCH, error.code)
276
- assert_equal(XML::Error::FATAL, error.level)
277
- assert_nil(error.file)
278
- assert_equal(1, error.line)
279
- assert_equal('foo', error.str1)
280
- assert_equal('foz', error.str2)
281
- assert_nil(error.str3)
282
- assert_equal(1, error.int1)
283
- assert_equal(20, error.int2)
284
- assert_nil(error.node)
285
- end
286
-
287
- def test_bad_xml
288
- parser = XML::Parser.string('<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
289
- error = assert_raise(XML::Error) do
290
- assert_not_nil(parser.parse)
291
- end
292
-
293
- assert_not_nil(error)
294
- assert_kind_of(XML::Error, error)
295
- assert_equal("Fatal error: Extra content at the end of the document at :1.", error.message)
296
- assert_equal(XML::Error::PARSER, error.domain)
297
- assert_equal(XML::Error::DOCUMENT_END, error.code)
298
- assert_equal(XML::Error::FATAL, error.level)
299
- assert_nil(error.file)
300
- assert_equal(1, error.line)
301
- assert_nil(error.str1)
302
- assert_nil(error.str2)
303
- assert_nil(error.str3)
304
- assert_equal(0, error.int1)
305
- assert_equal(20, error.int2)
306
- assert_nil(error.node)
307
- end
308
-
309
- # Deprecated methods
310
- def test_document_deprecated
311
- file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
312
- parser = XML::Parser.file(file)
313
- doc = parser.parse
314
-
315
- parser = XML::Parser.new
316
- parser.document = doc
317
- doc = parser.parse
318
-
319
- assert_instance_of(XML::Document, doc)
320
- assert_instance_of(XML::Parser::Context, parser.context)
321
- end
322
-
323
- def test_file_deprecated
324
- file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
325
-
326
- parser = XML::Parser.new
327
- parser.file = file
328
- doc = parser.parse
329
- assert_instance_of(XML::Document, doc)
330
- assert_instance_of(XML::Parser::Context, parser.context)
331
- end
332
-
333
- def test_io_deprecated
334
- File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
335
- parser = XML::Parser.new
336
- assert_instance_of(XML::Parser, parser)
337
- parser.io = io
338
-
339
- doc = parser.parse
340
- assert_instance_of(XML::Document, doc)
341
- assert_instance_of(XML::Parser::Context, parser.context)
342
- end
343
- end
344
-
345
- def test_string_deprecated
346
- str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
347
-
348
- parser = XML::Parser.new
349
- parser.string = str
350
- assert_instance_of(XML::Parser, parser)
351
-
352
- doc = parser.parse
353
- assert_instance_of(XML::Document, doc)
354
- assert_instance_of(XML::Parser::Context, parser.context)
355
- end
356
- <<<<<<< HEAD
357
- =======
358
-
359
- def test_errors_from_background_thread
360
- errors = []
361
- background_errors = []
362
-
363
- begin
364
- XML::Error.set_handler do |error|
365
- errors << error
366
- end
367
- parser = XML::Parser.string("<moo>")
368
-
369
- thread = Thread.new do
370
- XML::Error.set_handler do |error|
371
- background_errors << error
372
- end
373
- parser.parse rescue nil
374
- end
375
- thread.join
376
- ensure
377
- XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
378
- end
379
-
380
- assert_equal(errors.size, 0)
381
- assert_equal(background_errors.size, 1)
382
- end
383
- >>>>>>> a1cd317d43c1c1f23551545e431452508720668d
384
- end