summaryrefslogtreecommitdiff
path: root/jni/ruby/test/rexml/test_sax.rb
blob: 2d37ec9dfbd825d5b6746280c8f49cfa5476f7f5 (plain)
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
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
require_relative "rexml_test_utils"
require 'rexml/sax2listener'
require 'rexml/parsers/sax2parser'
require 'rexml/document'

module REXMLTests
  class SAX2Tester < Test::Unit::TestCase
    include REXMLTestUtils
    include REXML
    def test_characters
      d = Document.new( "<A>@blah@</A>" )
      txt = d.root.text
      p = Parsers::SAX2Parser.new "<A>@blah@</A>"
      p.listen(:characters) {|x| assert_equal txt, x}
      p.listen(:characters, ["A"]) {|x| assert_equal txt,x}
      p.parse
    end

    def test_entity_replacement
      source = '<!DOCTYPE foo [
      <!ENTITY la "1234">
      <!ENTITY lala "--&la;--">
      <!ENTITY lalal "&la;&la;">
      ]><a><la>&la;</la><lala>&lala;</lala></a>'
      sax = Parsers::SAX2Parser.new( source )
      results = []
      sax.listen(:characters) {|x| results << x }
      sax.parse
      assert_equal 2, results.size
      assert_equal '1234', results[0]
      assert_equal '--1234--', results[1]
    end

    def test_sax2
      File.open(fixture_path("documentation.xml")) do |f|
        parser = Parsers::SAX2Parser.new( f )
        # Listen to all events on the following elements
        count = 0
        blok = proc { |uri,localname,qname,attributes|
          assert %w{ bugs todo }.include?(localname),
          "Mismatched name; we got '#{qname}'\nArgs were:\n\tURI: #{uri}\n\tLOCALNAME: #{localname}\n\tQNAME: #{qname}\n\tATTRIBUTES: #{attributes.inspect}\n\tSELF=#{blok}"
          count += 1
        }

        start_document = 0
        end_document = 0
        parser.listen( :start_document ) { start_document += 1 }
        parser.listen( :end_document ) { end_document += 1 }
        parser.listen( :start_element, %w{ changelog bugs todo }, &blok )
        # Listen to all events on the following elements.  Synonymous with
        # listen( :start_element, %w{ ... } )
        parser.listen( %w{ changelog bugs todo }, &blok )
        # Listen for all start element events
        parser.listen( :start_element ) { |uri,localname,qname,attributes|
        }
        listener = MySAX2Listener.new
        # Listen for all events
        parser.listen( listener )
        # Listen for all events on the given elements.  Does not include children
        # events.  Regular expressions work as well!
        parser.listen( %w{ /change/ bugs todo }, listener )
        # Test the deafening method
        blok = proc  { |uri,localname,qname,attributes|
          assert_fail "This listener should have been deafened!"
        }
        parser.listen( %w{ changelog }, &blok )
        parser.deafen( &blok )

        tc = 0
        parser.listen( :characters, %w{version} ) {|text|
          assert(text=~/@ANT_VERSION@/, "version was '#{text}'")
          tc += 1
        }

        begin
          parser.parse
        rescue => exception
          if exception.kind_of? Test::Unit::AssertionFailedError
            raise exception
          end
          puts $!
          puts exception.backtrace
        end
        assert_equal 2, count
        assert_equal 1, tc
        assert_equal 1, start_document
        assert_equal 1, end_document
      end
    end

    # used by test_simple_doctype_listener
    # submitted by Jeff Barczewski
    class SimpleDoctypeListener
      include REXML::SAX2Listener
      attr_reader :name, :pub_sys, :long_name, :uri

      def initialize
        @name = @pub_sys = @long_name = @uri = nil
      end

      def doctype(name, pub_sys, long_name, uri)
        @name = name
        @pub_sys = pub_sys
        @long_name = long_name
        @uri = uri
      end
    end

    # test simple non-entity doctype in sax listener
    # submitted by Jeff Barczewski
    def test_simple_doctype_listener
      xml = <<-END
        <?xml version="1.0"?>
        <!DOCTYPE greeting PUBLIC "Hello Greeting DTD" "http://foo/hello.dtd">
        <greeting>Hello, world!</greeting>
      END
      parser = Parsers::SAX2Parser.new(xml)
      dtl = SimpleDoctypeListener.new
      parser.listen(dtl)
      tname = nil
      tpub_sys = nil
      tlong_name = nil
      turi = nil
      parser.listen(:doctype) do |name, pub_sys, long_name, uri|
        tname = name
        tpub_sys = pub_sys
        tlong_name = long_name
        turi = uri
      end
      parser.parse
      assert_equal 'greeting', tname, 'simple doctype block listener failed - incorrect name'
      assert_equal 'PUBLIC', tpub_sys, 'simple doctype block listener failed - incorrect pub_sys'
      assert_equal 'Hello Greeting DTD', tlong_name, 'simple doctype block listener failed - incorrect long_name'
      assert_equal 'http://foo/hello.dtd', turi, 'simple doctype block listener failed - incorrect uri'
      assert_equal 'greeting', dtl.name, 'simple doctype listener failed - incorrect name'
      assert_equal 'PUBLIC', dtl.pub_sys, 'simple doctype listener failed - incorrect pub_sys'
      assert_equal 'Hello Greeting DTD', dtl.long_name, 'simple doctype listener failed - incorrect long_name'
      assert_equal 'http://foo/hello.dtd', dtl.uri, 'simple doctype listener failed - incorrect uri'
    end

    # test doctype with missing name, should throw ParseException
    # submitted by Jeff Barczewseki
    def test_doctype_with_mising_name_throws_exception
      xml = <<-END
        <?xml version="1.0"?>
        <!DOCTYPE >
        <greeting>Hello, world!</greeting>
      END
      parser = Parsers::SAX2Parser.new(xml)
      assert_raise(REXML::ParseException, 'doctype missing name did not throw ParseException') do
        parser.parse
      end
    end


    class KouListener
      include REXML::SAX2Listener
      attr_accessor :sdoc, :edoc
      attr_reader :selem, :decl, :pi
      def initialize
        @sdoc = @edoc = @selem = false
        @decl = 0
        @pi = 0
      end
      def start_document
        @sdoc = true
      end
      def end_document
        @edoc = true
      end
      def xmldecl( *arg )
        @decl += 1
      end
      def processing_instruction( *arg )
        @pi += 1
      end
      def start_element( *arg )
        @selem = true
      end
    end

    # Submitted by Kou
    def test_begin_end_document
      parser = Parsers::SAX2Parser.new("<a/>")

      kl = KouListener.new
      parser.listen(kl)
      sd = false
      ed = false
      parser.listen(:start_document) { sd = true }
      parser.listen(:end_document) { ed = true }

      parser.parse
      assert( sd, ':start_document block failed' )
      assert( ed, ':end_document block failed' )
      assert( kl.sdoc, ':start_document listener failed' )
      assert( kl.edoc, ':end_document listener failed' )
    end

    # Submitted by Kou
    def test_listen_before_start
      # FIXME: the following comment should be a test for validity. (The xml declaration
      # is invalid).
      #parser =  Parsers::SAX2Parser.new( "<?xml ?><?pi?><a><?pi?></a>")
      parser =  Parsers::SAX2Parser.new( "<?xml version='1.0'?><?pi?><a><?pi?></a>")
      k1 = KouListener.new
      parser.listen( k1 )
      xmldecl = false
      pi = 0
      parser.listen( :xmldecl ) { xmldecl = true }
      parser.listen( :processing_instruction ) { pi += 1 }

      parser.parse

      assert( xmldecl, ':xmldecl failed' )
      assert_equal( 2, pi, ':processing_instruction failed' )
      assert( k1.decl, 'Listener for xmldecl failed' )
      assert_equal( 2, k1.pi, 'Listener for processing instruction failed' )
    end


    def test_socket
      require 'socket'

      TCPServer.open('127.0.0.1', 0) do |server|
        TCPSocket.open('127.0.0.1', server.addr[1]) do |socket|
          ok = false
          session = server.accept
          begin
            session << '<foo>'
            parser = REXML::Parsers::SAX2Parser.new(socket)
            Fiber.new do
              parser.listen(:start_element) do
                ok = true
                Fiber.yield
              end
              parser.parse
            end.resume
            assert(ok)
          ensure
            session.close
          end
        end
      end
    end

    def test_char_ref_sax2()
      parser = REXML::Parsers::SAX2Parser.new('<ABC>&#252;</ABC>')
      result = nil
      parser.listen(:characters) {|text| result = text.unpack('U*')}
      parser.parse()
      assert_equal(1, result.size)
      assert_equal(252, result[0])
    end


    def test_char_ref_dom()
      doc = REXML::Document.new('<ABC>&#252;</ABC>')
      result = doc.root.text.unpack('U*')
      assert_equal(1, result.size)
      assert_equal(252, result[0])
    end

    class Ticket68
      include REXML::SAX2Listener
    end
    def test_ticket_68
      File.open(fixture_path('ticket_68.xml')) do |f|
        parser = REXML::Parsers::SAX2Parser.new(f)
        parser.listen( Ticket68.new )
        begin
          parser.parse
        rescue
          p parser.source.position
          p parser.source.current_line
          puts $!.backtrace.join("\n")
          flunk $!.message
        end
      end
    end
  end

  class MySAX2Listener
    include REXML::SAX2Listener
  end
end