예제 #1
0
        def client_connect_handler(socket):
            tu.check_context()
            sends = 10
            size = 100

            sent = Buffer.create()
            received = Buffer.create()

            @socket.data_handler
            def data_handler(data):
                tu.check_context()
                received.append_buffer(data)
                if received.length == sends * size:
                    tu.azzert(TestUtils.buffers_equal(sent, received))
                    tu.test_complete()
            @socket.drain_handler
            def drain_handler(stream):
                tu.check_context()
                #print "drained\n"

            @socket.end_handler
            def end_handler(stream):
                tu.check_context()
                #print "end\n"

            socket.pause()
            socket.resume()
            socket.write_queue_full
            socket.write_queue_max_size = 100000

            for i in range(0, sends):
                data = TestUtils.gen_buffer(size)
                sent.append_buffer(data)
                socket.write_buffer(data)
예제 #2
0
        def client_connect_handler(socket):
            tu.check_context()
            sends = 10
            size = 100

            sent = Buffer.create()
            received = Buffer.create()

            @socket.data_handler
            def data_handler(data):
                tu.check_context()
                received.append_buffer(data)
                if received.length == sends * size:
                    tu.azzert(TestUtils.buffers_equal(sent, received))
                    tu.test_complete()

            @socket.drain_handler
            def drain_handler(stream):
                tu.check_context()
                #print "drained\n"

            @socket.end_handler
            def end_handler(stream):
                tu.check_context()
                #print "end\n"

            socket.pause()
            socket.resume()
            socket.write_queue_full
            socket.write_queue_max_size = 100000

            for i in range(0, sends):
                data = TestUtils.gen_buffer(size)
                sent.append_buffer(data)
                socket.write_buffer(data)
예제 #3
0
 def test_create(self):
     buff1 = Buffer.create()
     tu.azzert(0 == buff1.length)
     buff2 = Buffer.create(100)
     tu.azzert(0 == buff1.length)
     str = "oqkdioqjwdijqwed"
     buff3 = Buffer.create_from_str(str)
     tu.azzert(str == buff3.to_string())
     tu.test_complete()
예제 #4
0
 def test_create(self):
     buff1 = Buffer.create()
     tu.azzert(0 == buff1.length)
     buff2 = Buffer.create(100)
     tu.azzert(0 == buff1.length)
     str = "oqkdioqjwdijqwed"
     buff3 = Buffer.create_from_str(str)
     tu.azzert(str == buff3.to_string())
     tu.test_complete()
예제 #5
0
 def open_handler(err, file):
     tu.check_thread()
     tu.azzert(err == None)
     num_chunks = 100;
     chunk_size = 1000;
     tot_buff = Buffer.create()
     self.written = 0
     for i in range(0, num_chunks):
         buff = TestUtils.gen_buffer(chunk_size)
         tot_buff.append_buffer(buff)
         def write_handler(err, res):
             tu.check_thread()
             self.written += 1
             if self.written == num_chunks:
               # all written
               tot_read = Buffer.create()
               self.read = 0
               for j in range(0, num_chunks):
                 pos = j * chunk_size
                 def read_handler(err, buff):
                     tu.check_thread
                     tu.azzert(err == None)
                     self.read += 1
                     if self.read == num_chunks:
                         # all read
                         tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read))
                         def close_handler(err, res):
                             tu.check_thread()
                             tu.test_complete()
                         file.close(close_handler)
                 file.read_at_pos(tot_read, pos, pos, chunk_size, read_handler)
         file.write_at_pos(buff, i * chunk_size, write_handler)
예제 #6
0
 def open_handler(err, file):
     tu.check_thread()
     tu.azzert(err == None)
     num_chunks = 100;
     chunk_size = 1000;
     tot_buff = Buffer.create()
     for i in range(0, num_chunks):
         buff = TestUtils.gen_buffer(chunk_size)
         tot_buff.append_buffer(buff)
         file.write(buff)
     def close_handler(err, file):
         def open_handler2(err, file):
             tu.check_thread()
             tu.azzert(err == None)
             read_stream = file
             tot_read = Buffer.create()
             def data_handler(data):
                 tot_read.append_buffer(data)  
             read_stream.data_handler(data_handler)
             def end_handler():
                 tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read))
                 tu.check_thread
                 def close_handler2(err, result):
                     tu.check_thread()
                     tu.test_complete()
                 file.close(close_handler2)
             read_stream.end_handler(end_handler)
         fs.open(filename, handler=open_handler2)
     
     file.close(close_handler)
예제 #7
0
 def test_set_buff_with_offset(self):
     buff_len = 100
     buff1 = self.create_buffer(buff_len)
     buff2 = Buffer.create()
     buff2.set_buffer(0, buff1, 50, 50)
     tu.azzert(50 == buff2.length, 'Invalid length')
     tu.test_complete()
예제 #8
0
    def request_handler(req):
        tu.check_context()
        tu.azzert(req.uri == uri)
        tu.azzert(req.method == method)
        tu.azzert(req.path == path)
        tu.azzert(req.query == query)
        tu.azzert(req.headers["header1"] == "vheader1")
        tu.azzert(req.headers["header2"] == "vheader2")
        tu.azzert(req.params["param1"] == "vparam1")
        tu.azzert(req.params["param2"] == "vparam2")
        req.response.put_header("rheader1", "vrheader1")
        req.response.put_header("rheader2", "vrheader2")
        body = Buffer.create()

        @req.data_handler
        def data_handler(data):
            tu.check_context()
            body.append_buffer(data)

        req.response.chunked = chunked

        @req.end_handler
        def end_handler(stream):
            tu.check_context()
            if method != "HEAD" and method != "CONNECT":
                if not chunked:
                    req.response.put_header("Content-Length", body.length)
                req.response.write_buffer(body)
                if chunked:
                    req.response.put_trailer("trailer1", "vtrailer1")
                    req.response.put_trailer("trailer2", "vtrailer2")
            req.response.end()
예제 #9
0
                def write_handler(err, res):
                    tu.check_context()
                    self.written += 1
                    if self.written == num_chunks:
                        # all written
                        tot_read = Buffer.create()
                        self.read = 0
                        for j in range(0, num_chunks):
                            pos = j * chunk_size

                            def read_handler(err, buff):
                                tu.check_context
                                tu.azzert(err == None)
                                self.read += 1
                                if self.read == num_chunks:
                                    # all read
                                    tu.azzert(
                                        TestUtils.buffers_equal(
                                            tot_buff, tot_read))

                                    def close_handler(err, res):
                                        tu.check_context()
                                        tu.test_complete()

                                    file.close(close_handler)

                            file.read(tot_read, pos, pos, chunk_size,
                                      read_handler)
예제 #10
0
 def test_set_buff_with_offset(self):
     buff_len = 100
     buff1 = self.create_buffer(buff_len)
     buff2 = Buffer.create()
     buff2.set_buffer(0, buff1, 50, 50)
     tu.azzert(50 == buff2.length, 'Invalid length')
     tu.test_complete()
예제 #11
0
 def test_append_buff(self):
     buff_len = 100
     buff1 = self.create_buffer(buff_len)
     buff2 = Buffer.create()
     buff2.append_buffer(buff1)
     tu.azzert(buff_len == buff2.length, 'Invalid length')
     tu.test_complete()
예제 #12
0
                def write_handler(err, res):
                    tu.check_thread()
                    self.written += 1
                    if self.written == num_chunks:
                        # all written
                        tot_read = Buffer.create()
                        self.read = 0
                        for j in range(0, num_chunks):
                            pos = j * chunk_size

                            def read_handler(err, buff):
                                tu.check_thread
                                tu.azzert(err == None)
                                self.read += 1
                                if self.read == num_chunks:
                                    # all read
                                    tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read))

                                    def close_handler(err, res):
                                        tu.check_thread()
                                        tu.test_complete()

                                    file.close(close_handler)

                            file.read_at_pos(tot_read, pos, pos, chunk_size, read_handler)
예제 #13
0
 def open_handler(err, file):
     tu.check_context()
     tu.azzert(err == None)
     num_chunks = 100;
     chunk_size = 1000;
     tot_buff = Buffer.create()
     self.written = 0
     for i in range(0, num_chunks):
         buff = TestUtils.gen_buffer(chunk_size)
         tot_buff.append_buffer(buff)
         def write_handler(err, res):
             tu.check_context()
             self.written += 1
             if self.written == num_chunks:
               # all written
               tot_read = Buffer.create()
               self.read = 0
               for j in range(0, num_chunks):
                 pos = j * chunk_size
                 def read_handler(err, buff):
                     tu.check_context
                     tu.azzert(err == None)
                     self.read += 1
                     if self.read == num_chunks:
                         # all read
                         tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read))
                         def close_handler(err, res):
                             tu.check_context()
                             tu.test_complete()
                         file.close(close_handler)
                 file.read(tot_read, pos, pos, chunk_size, read_handler)
         file.write(buff, i * chunk_size, write_handler)
예제 #14
0
 def open_handler(err, file):
     tu.check_context()
     tu.azzert(err == None)
     num_chunks = 100;
     chunk_size = 1000;
     tot_buff = Buffer.create()
     write_stream = file.write_stream
     for i in range(0, num_chunks):
         buff = TestUtils.gen_buffer(chunk_size)
         tot_buff.append_buffer(buff)
         write_stream.write_buffer(buff)
     def close_handler(err, file):
         def open_handler2(err, file):
             tu.check_context()
             tu.azzert(err == None)
             read_stream = file.read_stream
             tot_read = Buffer.create()
             def data_handler(data):
                 tot_read.append_buffer(data)  
             read_stream.data_handler(data_handler)
             def end_handler(stream):
                 tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read))
                 tu.check_context
                 def close_handler2(err, result):
                     tu.check_context()
                     tu.test_complete()
                 file.close(close_handler2)
             read_stream.end_handler(end_handler)
         FileSystem.open(filename, handler=open_handler2)
     
     file.close(close_handler)
예제 #15
0
    def request_handler(req):
        tu.check_context()
        tu.azzert(req.uri == uri)
        tu.azzert(req.method == method)
        tu.azzert(req.path == path)
        tu.azzert(req.query == query)
        tu.azzert(req.headers['header1'] == 'vheader1')
        tu.azzert(req.headers['header2'] == 'vheader2')
        tu.azzert(req.params['param1'] == 'vparam1')
        tu.azzert(req.params['param2'] == 'vparam2')
        req.response.put_header('rheader1', 'vrheader1')
        req.response.put_header('rheader2', 'vrheader2')
        body = Buffer.create()

        @req.data_handler
        def data_handler(data):
            tu.check_context()
            body.append_buffer(data)

        req.response.chunked = chunked

        @req.end_handler
        def end_handler(stream):
            tu.check_context()
            if not chunked:
                req.response.put_header('Content-Length', body.length)
            req.response.write_buffer(body)
            if chunked:
                req.response.put_trailer('trailer1', 'vtrailer1')
                req.response.put_trailer('trailer2', 'vtrailer2')
            req.response.end()
예제 #16
0
 def test_set_buff(self):
     buff_len = 100
     buff1 = self.create_buffer(buff_len)
     buff2 = Buffer.create()
     buff2.set_buffer(0, buff1)
     tu.azzert(buff_len == buff2.length, 'Invalid length')
     tu.test_complete()
예제 #17
0
    def request_handler(req):
        tu.check_context()
        tu.azzert(req.uri == uri)
        tu.azzert(req.method == method)
        tu.azzert(req.path == path)
        tu.azzert(req.query == query)
        tu.azzert(req.headers['header1'] == 'vheader1')
        tu.azzert(req.headers['header2'] == 'vheader2')
        tu.azzert(req.params['param1'] == 'vparam1')
        tu.azzert(req.params['param2'] == 'vparam2')
        req.response.put_header('rheader1', 'vrheader1')
        req.response.put_header('rheader2', 'vrheader2')
        body = Buffer.create()

        @req.data_handler
        def data_handler(data):
            tu.check_context()
            body.append_buffer(data)
        req.response.chunked = chunked

        @req.end_handler
        def end_handler(stream):
            tu.check_context()
            if not chunked:
                req.response.put_header('Content-Length', body.length)
            req.response.write_buffer(body)
            if chunked:
                req.response.put_trailer('trailer1', 'vtrailer1')
                req.response.put_trailer('trailer2', 'vtrailer2')
            req.response.end()
예제 #18
0
    def test_append_int(self):
        buff1 = Buffer.create()
        for i in range(100):
          buff1.append_int(i)

        for i in range(100):
          val = buff1.get_int(i)
          tu.azzert(val == i)
예제 #19
0
 def set_fixnum(self, num_bytes):
     buff1 = Buffer.create()
     for i in range(-128,128):
         buff1.set_fixnum((i + 128) * num_bytes, i << ((num_bytes -1) * 8), num_bytes)
     for i in range(-128,128):
         val = buff1.get_fixnum((i + 128) * num_bytes, num_bytes)
         tu.azzert(val == i << ((num_bytes -1)* 8))
     tu.test_complete()
예제 #20
0
    def test_set_int(self):
        buff1 = Buffer.create()
        for i in range(100):
            buff1.set_int(i, i)

        for i in range(100):
            val = buff1.get_int(i)
            tu.azzert(val == i)
예제 #21
0
 def test_copy(self):
     str = "iajdoiqwjdiqwdioqwdjiqwd"
     buff1 = Buffer.create(str)
     buff2 = buff1.copy()
     tu.azzert(buff1.length == buff2.length)
     for i in range(0,buff1.length):
         tu.azzert(buff1.get_byte(i) == buff2.get_byte(i))
     tu.test_complete()
예제 #22
0
 def test_length(self):
     buff1 = Buffer.create()
     tu.azzert(buff1.length == 0)
     num = 50
     for i in range(0,num):
         buff1.append_fixnum(i, 1)
     tu.azzert(buff1.length == num, "Received %d expected %d"% (buff1.length, num))
     tu.test_complete()
예제 #23
0
 def test_copy(self):
     str = "iajdoiqwjdiqwdioqwdjiqwd"
     buff1 = Buffer.create(str)
     buff2 = buff1.copy()
     tu.azzert(buff1.length == buff2.length)
     for i in range(0, buff1.length):
         tu.azzert(buff1.get_byte(i) == buff2.get_byte(i))
     tu.test_complete()
예제 #24
0
        def client_connect_handler(err, socket):
            tu.azzert(err == None)
            tu.check_thread()
            tu.azzert(socket.local_address[0] is not None)
            tu.azzert(socket.local_address[1] > -1)
            tu.azzert(socket.remote_address[0] is not None)
            tu.azzert(socket.remote_address[1] > -1)

            sends = 10
            size = 100

            sent = Buffer.create()
            received = Buffer.create()

            @socket.data_handler
            def data_handler(data):
                tu.check_thread()
                received.append_buffer(data)

                if received.length == sends * size:
                    tu.azzert(TestUtils.buffers_equal(sent, received))
                    tu.test_complete()

            #Just call the methods. Real testing is done in java tests
            @socket.drain_handler
            def drain_handler():
                tu.check_thread()

            @socket.end_handler
            def end_handler():
                tu.check_thread()

            @socket.close_handler
            def close_handler():
                tu.check_thread()

            socket.pause()
            socket.resume()
            socket.write_queue_full
            socket.write_queue_max_size = 100000

            for i in range(0, sends):
                data = TestUtils.gen_buffer(size)
                sent.append_buffer(data)
                socket.write(data)
예제 #25
0
        def client_connect_handler(err, socket):
            tu.azzert(err == None)
            tu.check_thread()
            tu.azzert(socket.local_address[0] is not None)
            tu.azzert(socket.local_address[1] > -1)
            tu.azzert(socket.remote_address[0] is not None)
            tu.azzert(socket.remote_address[1] > -1)

            sends = 10
            size = 100

            sent = Buffer.create()
            received = Buffer.create()

            @socket.data_handler
            def data_handler(data):
                tu.check_thread()
                received.append_buffer(data)

                if received.length == sends * size:
                    tu.azzert(TestUtils.buffers_equal(sent, received))
                    tu.test_complete()

            #Just call the methods. Real testing is done in java tests
            @socket.drain_handler
            def drain_handler():
                tu.check_thread()

            @socket.end_handler
            def end_handler():
                tu.check_thread()

            @socket.close_handler
            def close_handler():
                tu.check_thread()

            socket.pause()
            socket.resume()
            socket.write_queue_full
            socket.write_queue_max_size = 100000

            for i in range(0, sends):
                data = TestUtils.gen_buffer(size)
                sent.append_buffer(data)
                socket.write(data)
예제 #26
0
 def test_length(self):
     buff1 = Buffer.create()
     tu.azzert(buff1.length == 0)
     num = 50
     for i in range(0, num):
         buff1.append_str("1")
     tu.azzert(buff1.length == num,
               "Received %d expected %d" % (buff1.length, num))
     tu.test_complete()
예제 #27
0
 def set_fixnum(self, num_bytes):
     buff1 = Buffer.create()
     for i in range(-128, 128):
         buff1.set_fixnum((i + 128) * num_bytes, i << ((num_bytes - 1) * 8),
                          num_bytes)
     for i in range(-128, 128):
         val = buff1.get_fixnum((i + 128) * num_bytes, num_bytes)
         tu.azzert(val == i << ((num_bytes - 1) * 8))
     tu.test_complete()
예제 #28
0
    def append_float(self, num_bytes):
        buff1 = Buffer.create()
        for i in range(0,100):
            buff1.append_float(i, num_bytes)

        for i in range(0,100):
            val = buff1.get_float(i * num_bytes, num_bytes)
            tu.azzert(val == i)
        tu.test_complete()
예제 #29
0
    def append_float(self, num_bytes):
        buff1 = Buffer.create()
        for i in range(0, 100):
            buff1.append_float(i, num_bytes)

        for i in range(0, 100):
            val = buff1.get_float(i * num_bytes, num_bytes)
            tu.azzert(val == i)
        tu.test_complete()
예제 #30
0
        def client_connect_handler(socket):
            tu.check_context()
            sent = 'some-string'
            received = Buffer.create()

            @socket.data_handler
            def data_handler(data):
                tu.check_context()
                received.append_buffer(data)

                if received.length == len(sent):
                    tu.azzert(sent == received.to_string())
                    tu.test_complete()

            socket.write_str(sent)
예제 #31
0
        def client_connect_handler(socket):
            tu.check_context()
            sent = 'some-string'
            received = Buffer.create()

            @socket.data_handler
            def data_handler(data):
                tu.check_context()
                received.append_buffer(data)

                if received.length == len(sent):
                    tu.azzert(sent == received.to_string())
                    tu.test_complete()

            socket.write_str(sent)
예제 #32
0
 def open_handler2(err, file):
     tu.check_thread()
     tu.azzert(err == None)
     read_stream = file
     tot_read = Buffer.create()
     def data_handler(data):
         tot_read.append_buffer(data)  
     read_stream.data_handler(data_handler)
     def end_handler():
         tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read))
         tu.check_thread
         def close_handler2(err, result):
             tu.check_thread()
             tu.test_complete()
         file.close(close_handler2)
     read_stream.end_handler(end_handler)
예제 #33
0
        def connect_handler(ws):
            tu.check_context()
            received = Buffer.create()

            @ws.data_handler
            def data_handler(buff):
                tu.check_context()
                received.append_buffer(buff)
                if received.length == buff.length:
                    tu.azzert(TestUtils.buffers_equal(buff, received))
                    tu.test_complete()
        
            if binary:
                ws.write_binary_frame(self.buff)
            else:
                ws.write_text_frame(self.str_)
예제 #34
0
 def open_handler2(err, file):
     tu.check_context()
     tu.azzert(err == None)
     read_stream = file.read_stream
     tot_read = Buffer.create()
     def data_handler(data):
         tot_read.append_buffer(data)  
     read_stream.data_handler(data_handler)
     def end_handler(stream):
         tu.azzert(TestUtils.buffers_equal(tot_buff, tot_read))
         tu.check_context
         def close_handler2(err, result):
             tu.check_context()
             tu.test_complete()
         file.close(close_handler2)
     read_stream.end_handler(end_handler)
예제 #35
0
        def connect_handler(ws):
            tu.check_thread()
            received = Buffer.create()

            @ws.data_handler
            def data_handler(buff):
                tu.check_thread()
                received.append_buffer(buff)
                if received.length == buff.length:
                    tu.azzert(TestUtils.buffers_equal(buff, received))
                    tu.test_complete()

            if binary:
                ws.write_binary_frame(self.buff)
            else:
                ws.write_text_frame(self.str_)
예제 #36
0
    def request_handler(req):
        tu.check_thread()
        tu.azzert(req.version == 'HTTP_1_1')
        tu.azzert(req.uri == uri)
        tu.azzert(req.method == method)
        tu.azzert(req.path == path)
        tu.azzert(req.query == query)
        tu.azzert(req.headers['header1'] == 'vheader1')
        tu.azzert(req.headers['header2'] == 'vheader2')
        tu.azzert(req.params['param1'] == 'vparam1')
        tu.azzert(req.params['param2'] == 'vparam2')


        headers = req.headers
        tu.azzert(headers.contains('header1'))
        tu.azzert(headers.contains('header2'))
        tu.azzert(headers.contains('header3'))
        tu.azzert(not headers.is_empty)

        headers.remove('header3')
        tu.azzert(not headers.contains('header3'))

        req.response.put_header('rheader1', 'vrheader1')
        req.response.put_header('rheader2', 'vrheader2')
        body = Buffer.create()

        @req.data_handler
        def data_handler(data):
            tu.check_thread()
            body.append_buffer(data)

        if method != 'HEAD' and method != 'CONNECT':
            req.response.chunked = chunked

        @req.end_handler
        def end_handler():
            tu.check_thread()
            if method != 'HEAD' and method != 'CONNECT':
                if not chunked:
                    req.response.put_header('Content-Length', str(body.length))
                req.response.write(body)
                if chunked:
                    req.response.put_trailer('trailer1', 'vtrailer1')
                    req.response.put_trailer('trailer2', 'vtrailer2')
            req.response.end()
예제 #37
0
        def listen_handler (err, serv):
            tu.azzert(err is None)
            client.port = 8080

            def post_handler(resp):
                # assert the response
                tu.azzert(200 == resp.status_code)
                @resp.body_handler
                def body_handler(body):
                    tu.azzert(0 == body.length)
                tu.test_complete()

            req = client.post("/form", post_handler)
            buffer = Buffer.create()
            buffer.append_str('framework=vertx&runson=jvm')
            req.put_header('content-length', str(buffer.length))
            req.put_header('content-type', 'application/x-www-form-urlencoded')
            req.write(buffer).end()
예제 #38
0
    def request_handler(req):
        tu.check_thread()
        tu.azzert(req.version == 'HTTP_1_1')
        tu.azzert(req.uri == uri)
        tu.azzert(req.method == method)
        tu.azzert(req.path == path)
        tu.azzert(req.query == query)
        tu.azzert(req.headers['header1'] == 'vheader1')
        tu.azzert(req.headers['header2'] == 'vheader2')
        tu.azzert(req.params['param1'] == 'vparam1')
        tu.azzert(req.params['param2'] == 'vparam2')

        headers = req.headers
        tu.azzert(headers.contains('header1'))
        tu.azzert(headers.contains('header2'))
        tu.azzert(headers.contains('header3'))
        tu.azzert(not headers.is_empty)

        headers.remove('header3')
        tu.azzert(not headers.contains('header3'))

        req.response.put_header('rheader1', 'vrheader1')
        req.response.put_header('rheader2', 'vrheader2')
        body = Buffer.create()

        @req.data_handler
        def data_handler(data):
            tu.check_thread()
            body.append_buffer(data)

        if method != 'HEAD' and method != 'CONNECT':
            req.response.chunked = chunked

        @req.end_handler
        def end_handler():
            tu.check_thread()
            if method != 'HEAD' and method != 'CONNECT':
                if not chunked:
                    req.response.put_header('Content-Length', str(body.length))
                req.response.write(body)
                if chunked:
                    req.response.put_trailer('trailer1', 'vtrailer1')
                    req.response.put_trailer('trailer2', 'vtrailer2')
            req.response.end()
예제 #39
0
    def response_handler(resp):
        tu.check_context()
        tu.azzert(200 == resp.status_code)
        tu.azzert('vrheader1' == resp.headers['rheader1'])
        tu.azzert('vrheader2' == resp.headers['rheader2'])
        body = Buffer.create()

        @resp.data_handler
        def data_handler(data):
            tu.check_context()
            body.append_buffer(data)

        @resp.end_handler
        def end_handler(stream):
            tu.check_context()
            tu.azzert(TestUtils.buffers_equal(sent_buff, body))
            if chunked:
                tu.azzert('vtrailer1' == resp.trailers['trailer1'])
                tu.azzert('vtrailer2' == resp.trailers['trailer2'])
            tu.test_complete()
예제 #40
0
    def response_handler(resp):
        tu.check_context()
        tu.azzert(200 == resp.status_code)
        tu.azzert('vrheader1' == resp.headers['rheader1'])
        tu.azzert('vrheader2' == resp.headers['rheader2'])
        body = Buffer.create()
        
        @resp.data_handler
        def data_handler(data):
            tu.check_context()
            body.append_buffer(data)

        @resp.end_handler
        def end_handler(stream):
            tu.check_context()
            tu.azzert(TestUtils.buffers_equal(sent_buff, body))
            if chunked:
                tu.azzert('vtrailer1' == resp.trailers['trailer1'])
                tu.azzert('vtrailer2' == resp.trailers['trailer2'])
            tu.test_complete()
예제 #41
0
        def listen_handler(err, serv):
            tu.azzert(err is None)
            client.port = 8080

            def post_handler(resp):
                # assert the response
                tu.azzert(200 == resp.status_code)

                @resp.body_handler
                def body_handler(body):
                    tu.azzert(0 == body.length)

                tu.test_complete()

            req = client.post("/form", post_handler)
            buffer = Buffer.create()
            buffer.append_str('framework=vertx&runson=jvm')
            req.put_header('content-length', str(buffer.length))
            req.put_header('content-type', 'application/x-www-form-urlencoded')
            req.write(buffer).end()
예제 #42
0
        def listen_handler (err, serv):
            tu.azzert(err is None)
            client.port = 8080

            def post_handler(resp):
                # assert the response
                tu.azzert(200 == resp.status_code)
                @resp.body_handler
                def body_handler(body):
                    tu.azzert(0 == body.length)
                tu.test_complete()

            req = client.post("/form", post_handler)
            boundary = "dLV9Wyq26L_-JQxk6ferf-RT153LhOO"
            buffer = Buffer.create()
            b = "--" + boundary + "\r\n" + "Content-Disposition: form-data; name=\"file\"; filename=\"tmp-0.txt\"\r\n" + "Content-Type: image/gif\r\n" + "\r\n" + content + "\r\n" + "--" + boundary + "--\r\n"

            buffer.append_str(b)
            req.put_header('content-length', str(buffer.length))
            req.put_header('content-type', 'multipart/form-data; boundary=' + boundary)
            req.write(buffer).end()
예제 #43
0
        def client_connect_handler(err, socket):
            tu.azzert(err == None)
            tu.check_thread()
            tu.azzert(socket.local_address[0] is not None)
            tu.azzert(socket.local_address[1] > -1)
            tu.azzert(socket.remote_address[0] is not None)
            tu.azzert(socket.remote_address[1] > -1)

            sent = 'some-string'
            received = Buffer.create()

            @socket.data_handler
            def data_handler(data):
                tu.check_thread()
                received.append_buffer(data)

                if received.length == len(sent):
                    tu.azzert(sent == received.to_string())
                    tu.test_complete()

            socket.write_str(sent)
예제 #44
0
    def response_handler(resp):
        tu.check_context()
        tu.azzert(200 == resp.status_code)
        tu.azzert("vrheader1" == resp.headers["rheader1"])
        tu.azzert("vrheader2" == resp.headers["rheader2"])
        body = Buffer.create()

        @resp.data_handler
        def data_handler(data):
            tu.check_context()
            body.append_buffer(data)

        @resp.end_handler
        def end_handler(stream):
            tu.check_context()
            if method != "HEAD" and method != "CONNECT":
                tu.azzert(TestUtils.buffers_equal(sent_buff, body))
                if chunked:
                    tu.azzert("vtrailer1" == resp.trailers["trailer1"])
                    tu.azzert("vtrailer2" == resp.trailers["trailer2"])
            tu.test_complete()
예제 #45
0
        def client_connect_handler(err, socket):
            tu.azzert(err == None)
            tu.check_thread()
            tu.azzert(socket.local_address[0] is not None)
            tu.azzert(socket.local_address[1] > -1)
            tu.azzert(socket.remote_address[0] is not None)
            tu.azzert(socket.remote_address[1] > -1)

            sent = 'some-string'
            received = Buffer.create()

            @socket.data_handler
            def data_handler(data):
                tu.check_thread()
                received.append_buffer(data)

                if received.length == len(sent):
                    tu.azzert(sent == received.to_string())
                    tu.test_complete()

            socket.write_str(sent)
예제 #46
0
    def response_handler(resp):
        tu.check_thread()
        tu.azzert(200 == resp.status_code)
        tu.azzert('vrheader1' == resp.headers['rheader1'])
        tu.azzert('vrheader2' == resp.headers['rheader2'])
        body = Buffer.create()
        
        @resp.data_handler
        def data_handler(data):
            tu.check_thread()
            body.append_buffer(data)

        @resp.end_handler
        def end_handler():
            tu.check_thread()
            if method != 'HEAD' and method != 'CONNECT':
                tu.azzert(TestUtils.buffers_equal(sent_buff, body))
                if chunked:
                    tu.azzert('vtrailer1' == resp.trailers['trailer1'])
                    tu.azzert('vtrailer2' == resp.trailers['trailer2'])

            resp.headers.clear()
            tu.azzert(resp.headers.is_empty)
            tu.test_complete()
예제 #47
0
        def listen_handler(err, serv):
            tu.azzert(err is None)
            client.port = 8080

            def post_handler(resp):
                # assert the response
                tu.azzert(200 == resp.status_code)

                @resp.body_handler
                def body_handler(body):
                    tu.azzert(0 == body.length)

                tu.test_complete()

            req = client.post("/form", post_handler)
            boundary = "dLV9Wyq26L_-JQxk6ferf-RT153LhOO"
            buffer = Buffer.create()
            b = "--" + boundary + "\r\n" + "Content-Disposition: form-data; name=\"file\"; filename=\"tmp-0.txt\"\r\n" + "Content-Type: image/gif\r\n" + "\r\n" + content + "\r\n" + "--" + boundary + "--\r\n"

            buffer.append_str(b)
            req.put_header('content-length', str(buffer.length))
            req.put_header('content-type',
                           'multipart/form-data; boundary=' + boundary)
            req.write(buffer).end()
예제 #48
0
    def response_handler(resp):
        tu.check_thread()
        tu.azzert(200 == resp.status_code)
        tu.azzert('vrheader1' == resp.headers['rheader1'])
        tu.azzert('vrheader2' == resp.headers['rheader2'])
        body = Buffer.create()

        @resp.data_handler
        def data_handler(data):
            tu.check_thread()
            body.append_buffer(data)

        @resp.end_handler
        def end_handler():
            tu.check_thread()
            if method != 'HEAD' and method != 'CONNECT':
                tu.azzert(TestUtils.buffers_equal(sent_buff, body))
                if chunked:
                    tu.azzert('vtrailer1' == resp.trailers['trailer1'])
                    tu.azzert('vtrailer2' == resp.trailers['trailer2'])

            resp.headers.clear()
            tu.azzert(resp.headers.is_empty)
            tu.test_complete()
예제 #49
0
 def test_append_string_2(self):
     buff1 = Buffer.create()
     str = "piajdioasdioasdoiasdjiqjiqdjiqwjidqwid"
     buff1.append_str(str, 'UTF-8')
     tu.azzert(str == buff1.to_string('UTF-8'))
     tu.test_complete()
예제 #50
0
 def test_append_string_2(self):
     buff1 = Buffer.create()
     str = "piajdioasdioasdoiasdjiqjiqdjiqwjidqwid"
     buff1.append_str(str, 'UTF-8')
     tu.azzert(str == buff1.to_string('UTF-8'))
     tu.test_complete()