Changeset 721

Show
Ignore:
Timestamp:
06/20/08 20:45:57 (5 months ago)
Author:
francis
Message:

removed defer calls for java, which doesn't seem to like them

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/tests/test_hc.rb

    r668 r721  
    3434# tests work. Native threads do strange things when you do I/O on them. 
    3535# 
     36# And it's even worse in Java, where I/O on native threads doesn't seem 
     37# to be reliable at all. 
     38# 
    3639 
    3740 
    3841class TestHeaderAndContentProtocol < Test::Unit::TestCase 
    3942 
    40     TestHost = "127.0.0.1" 
    41     TestPort = 8905 
    42  
    43  
    44     #-------------------------------------------------------------------- 
    45  
    46     class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol 
    47         attr_reader :first_header, :my_headers, :request 
    48  
    49         def receive_first_header_line hdr 
    50             @first_header ||= [] 
    51             @first_header << hdr 
    52         end 
    53         def receive_headers hdrs 
    54             @my_headers ||= [] 
    55             @my_headers << hdrs 
    56         end 
    57         def receive_request hdrs, content 
    58             @request ||= [] 
    59             @request << [hdrs, content] 
    60         end 
    61     end 
    62  
    63     def test_no_content 
    64         Thread.abort_on_exception = true 
    65         the_connection = nil 
    66         EventMachine.run { 
    67             EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    68                 the_connection = conn 
    69             end 
    70             EventMachine.add_timer(4) {raise "test timed out"} 
    71             EventMachine.defer proc { 
    72                 t = TCPSocket.new TestHost, TestPort 
    73                 t.write [ 
    74                     "aaa\n", "bbb\r\n", "ccc\n", "\n" 
    75                 ].join 
    76                 t.close 
    77                 if RUBY_VERSION =~ /\A1\.9\./ 
    78                         sleep 0.1 
    79                         STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
     43        TestHost = "127.0.0.1" 
     44        TestPort = 8905 
     45 
     46 
     47        #-------------------------------------------------------------------- 
     48 
     49        class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol 
     50                attr_reader :first_header, :my_headers, :request 
     51 
     52                def receive_first_header_line hdr 
     53                        @first_header ||= [] 
     54                        @first_header << hdr 
    8055                end 
    81             }, proc { 
    82                 EventMachine.stop 
    83             } 
    84         } 
    85         assert_equal( ["aaa"], the_connection.first_header ) 
    86         assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers ) 
    87         assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request ) 
    88     end 
    89  
    90     def test_content 
    91         Thread.abort_on_exception = true 
    92         the_connection = nil 
    93         content = "A" * 50 
    94         headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"] 
    95         EventMachine.run { 
    96             EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    97                 the_connection = conn 
    98             end 
    99             EventMachine.add_timer(4) {raise "test timed out"} 
    100             EventMachine.defer proc { 
    101                 t = TCPSocket.new TestHost, TestPort 
    102                 headers.each {|h| t.write "#{h}\r\n" } 
    103                 t.write "\n" 
    104                 t.write content 
    105                 t.close 
    106                 if RUBY_VERSION =~ /\A1\.9\./ 
    107                         sleep 0.1 
    108                         STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
     56                def receive_headers hdrs 
     57                        @my_headers ||= [] 
     58                        @my_headers << hdrs 
    10959                end 
    110             }, proc { 
    111                 EM.stop 
    112             } 
    113         } 
    114         assert_equal( ["aaa"], the_connection.first_header ) 
    115         assert_equal( [headers], the_connection.my_headers ) 
    116         assert_equal( [[headers, content]], the_connection.request ) 
    117     end 
    118  
    119     def test_several_requests 
    120         Thread.abort_on_exception = true 
    121         the_connection = nil 
    122         content = "A" * 50 
    123         headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"] 
    124         EventMachine.run { 
    125             EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    126                 the_connection = conn 
    127             end 
    128             EventMachine.add_timer(4) {raise "test timed out"} 
    129             EventMachine.defer proc { 
    130                 t = TCPSocket.new TestHost, TestPort 
    131                 5.times { 
    132                     headers.each {|h| t.write "#{h}\r\n" } 
    133                     t.write "\n" 
    134                     t.write content 
    135                 } 
    136                 t.close 
    137                 if RUBY_VERSION =~ /\A1\.9\./ 
    138                         sleep 0.1 
    139                         STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
     60                def receive_request hdrs, content 
     61                        @request ||= [] 
     62                        @request << [hdrs, content] 
    14063                end 
    141             }, proc { 
    142                 EventMachine.stop 
    143             } 
    144         } 
    145         assert_equal( ["aaa"] * 5, the_connection.first_header ) 
    146         assert_equal( [headers] * 5, the_connection.my_headers ) 
    147         assert_equal( [[headers, content]] * 5, the_connection.request ) 
    148     end 
     64        end 
     65 
     66 
     67        def test_no_content 
     68                Thread.abort_on_exception = true 
     69                the_connection = nil 
     70                EventMachine.run { 
     71                        EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     72                                the_connection = conn 
     73                        end 
     74                        EventMachine.add_timer(4) {raise "test timed out"} 
     75 
     76                        pr = proc { 
     77                                t = TCPSocket.new TestHost, TestPort 
     78                                t.write [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join 
     79                                t.close 
     80                        } 
     81 
     82                        if RUBY_PLATFORM =~ /java/i 
     83                                pr.call 
     84                                EM.add_timer(0.5) {EM.stop} 
     85                        else 
     86                                EventMachine.defer proc { 
     87                                        pr.call 
     88                                        if RUBY_VERSION =~ /\A1\.9\./ 
     89                                                sleep 0.1 
     90                                                STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
     91                                        end 
     92                                }, proc { 
     93                                        EventMachine.stop 
     94                                } 
     95                        end 
     96                } 
     97                assert_equal( ["aaa"], the_connection.first_header ) 
     98                assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers ) 
     99                assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request ) 
     100        end 
     101 
     102 
     103 
     104 
     105        def test_content 
     106                Thread.abort_on_exception = true 
     107                the_connection = nil 
     108                content = "A" * 50 
     109                headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"] 
     110                EventMachine.run { 
     111                        EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     112                                the_connection = conn 
     113                        end 
     114                        EventMachine.add_timer(4) {raise "test timed out"} 
     115 
     116                        pr = proc { 
     117                                t = TCPSocket.new TestHost, TestPort 
     118                                headers.each {|h| t.write "#{h}\r\n" } 
     119                                t.write "\n" 
     120                                t.write content 
     121                                t.close 
     122                        } 
     123 
     124                        if RUBY_PLATFORM =~ /java/i 
     125                                # I/O on threads seems completely unreliable in Java. 
     126                                pr.call 
     127                                EM.add_timer(0.5) {EM.stop} 
     128                        else 
     129                                EventMachine.defer proc { 
     130                                        pr.call 
     131                                        if RUBY_VERSION =~ /\A1\.9\./ 
     132                                                sleep 0.1 
     133                                                STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
     134                                        end 
     135                                }, proc { 
     136                                        EM.stop 
     137                                } 
     138                        end 
     139                } 
     140                assert_equal( ["aaa"], the_connection.first_header ) 
     141                assert_equal( [headers], the_connection.my_headers ) 
     142                assert_equal( [[headers, content]], the_connection.request ) 
     143        end 
     144 
     145 
     146 
     147        def test_several_requests 
     148                Thread.abort_on_exception = true 
     149                the_connection = nil 
     150                content = "A" * 50 
     151                headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"] 
     152                EventMachine.run { 
     153                        EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     154                                the_connection = conn 
     155                        end 
     156                        EventMachine.add_timer(4) {raise "test timed out"} 
     157 
     158                        pr = proc { 
     159                                t = TCPSocket.new TestHost, TestPort 
     160                                5.times { 
     161                                        headers.each {|h| t.write "#{h}\r\n" } 
     162                                        t.write "\n" 
     163                                        t.write content 
     164                                } 
     165                                t.close 
     166                        } 
     167 
     168                        if RUBY_PLATFORM =~ /java/i 
     169                                pr.call 
     170                                EM.add_timer(1) {EM.stop} 
     171                        else 
     172                                EventMachine.defer proc { 
     173                                        pr.call 
     174                                        if RUBY_VERSION =~ /\A1\.9\./ 
     175                                                sleep 0.1 
     176                                                STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
     177                                        end 
     178                                }, proc { 
     179                                        EventMachine.stop 
     180                                } 
     181                        end 
     182                } 
     183                assert_equal( ["aaa"] * 5, the_connection.first_header ) 
     184                assert_equal( [headers] * 5, the_connection.my_headers ) 
     185                assert_equal( [[headers, content]] * 5, the_connection.request ) 
     186        end 
    149187 
    150188 
    …… 
    172210    end 
    173211 
    174     def test_interpret_headers 
    175         Thread.abort_on_exception = true 
    176         the_connection = nil 
    177         content = "A" * 50 
    178         headers = [ 
    179             "GET / HTTP/1.0", 
    180             "Accept: aaa", 
    181             "User-Agent: bbb", 
    182             "Host:          ccc", 
    183             "x-tempest-header:ddd" 
    184         ] 
    185         EventMachine.run { 
    186             EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
    187                 the_connection = conn 
    188             end 
    189             EventMachine.add_timer(4) {raise "test timed out"} 
    190             EventMachine.defer proc { 
    191                 t = TCPSocket.new TestHost, TestPort 
    192                 headers.each {|h| t.write "#{h}\r\n" } 
    193                 t.write "\n" 
    194                 t.write content 
    195                 t.close 
    196                 if RUBY_VERSION =~ /\A1\.9\./ 
    197                         sleep 0.1 
    198                         STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
    199                 end 
    200             }, proc { 
    201                 EventMachine.stop 
    202             } 
    203         } 
    204  
    205         hsh = the_connection.headers_2_hash( the_connection.my_headers.shift ) 
    206         assert_equal( 
    207             { 
    208                 :accept => "aaa", 
    209                 :user_agent => "bbb", 
    210                 :host => "ccc", 
    211                 :x_tempest_header => "ddd" 
    212             }, 
    213             hsh 
    214          ) 
    215     end 
    216  
    217     #-------------------------------------------------------------------- 
     212        def test_interpret_headers 
     213                Thread.abort_on_exception = true 
     214                the_connection = nil 
     215                content = "A" * 50 
     216                headers = [ 
     217                        "GET / HTTP/1.0", 
     218                        "Accept: aaa", 
     219                        "User-Agent: bbb", 
     220                        "Host:      ccc", 
     221                        "x-tempest-header:ddd" 
     222                ] 
     223 
     224                EventMachine.run { 
     225                        EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn| 
     226                                the_connection = conn 
     227                        end 
     228                        EventMachine.add_timer(4) {raise "test timed out"} 
     229 
     230                        pr = proc { 
     231                                t = TCPSocket.new TestHost, TestPort 
     232                                headers.each {|h| t.write "#{h}\r\n" } 
     233                                t.write "\n" 
     234                                t.write content 
     235                                t.close 
     236                        } 
     237 
     238                        if RUBY_PLATFORM =~ /java/i 
     239                                pr.call 
     240                                EM.add_timer(0.5) {EM.stop} 
     241                        else 
     242                                EventMachine.defer proc { 
     243                                        pr.call 
     244                                        if RUBY_VERSION =~ /\A1\.9\./ 
     245                                                sleep 0.1 
     246                                                STDERR.puts "Introducing extraneous sleep for Ruby 1.9" 
     247                                        end 
     248                                }, proc { 
     249                                        EventMachine.stop 
     250                                } 
     251                        end 
     252                } 
     253 
     254                hsh = the_connection.headers_2_hash( the_connection.my_headers.shift ) 
     255                assert_equal( 
     256                        { 
     257                                :accept => "aaa", 
     258                                :user_agent => "bbb", 
     259                                :host => "ccc", 
     260                                :x_tempest_header => "ddd" 
     261                        }, 
     262                        hsh 
     263                ) 
     264        end 
     265 
    218266 
    219267end