コード例 #1
0
ファイル: test_stream.py プロジェクト: kasicass/fatuv
    def test_try_write(self):
        self.buffer = b''
        self.bytes_written = 0

        def on_read(connection, data, status):
            self.buffer += data
            connection.stop_read()

        def on_connection(pipe_handle, status):
            client = uv.Pipe(pipe_handle.loop)
            pipe_handle.accept(client)
            client.start_read(on_read)
            pipe_handle.close()

        def on_timeout(timer):
            try:
                self.bytes_written = self.client.try_write(b'hello')
            except uv.error.TemporaryUnavailableError:
                self.server.close()
            finally:
                timer.close()

        self.server = uv.Pipe(self.loop)
        self.server.bind(TEST_PIPE1)
        self.server.listen(on_connection)

        self.client = uv.Pipe(self.loop)
        self.client.connect(TEST_PIPE1)

        self.timer = uv.Timer(self.loop)
        self.timer.start(on_timeout, 1, 0)

        self.loop.run()

        self.assert_equal(self.buffer, b'hello'[:self.bytes_written])
コード例 #2
0
ファイル: test_process.py プロジェクト: cassyang/fatuv
    def test_process_hello(self):
        arguments = [sys.executable, PROGRAM_HELLO]
        self.buffer = b''
        self.returncode = None

        def on_exit(process_handle, returncode, term_signal):
            self.returncode = returncode

        def on_read(pipe_handle, data, status):
            if data:
                self.buffer += data

        self.pipe = uv.Pipe(self.loop)
        self.pipe.bind(TEST_PIPE1)

        self.process = uv.Process(self.loop,
                                  arguments,
                                  stdout=uv.process.PIPE,
                                  stdio=[self.pipe],
                                  callback=on_exit)
        self.process.stdout.start_read(on_read)

        self.loop.run()

        self.assert_equal(self.buffer.strip(), b'hello')
        self.assert_equal(self.returncode, 1)
        self.assert_not_equal(self.process.pid, None)
        self.assert_raises(uv.error.UVError, self.process.kill)

        self.process.close()

        self.assert_raises(uv.HandleClosedError, self.process.kill)
        with self.should_raise(uv.HandleClosedError):
            pid = self.process.pid
コード例 #3
0
    def test_peername(self):
        def on_connect(stream, status):
            self.assert_equal(status, uv.error.STATUS_SUCCESS)
            #self.assert_equal(request.stream.peername, TEST_PIPE1)
            stream.close()

        def on_connection(handle, status):
            self.assert_equal(status, uv.error.STATUS_SUCCESS)
            handle.close()

        self.pipe1 = uv.Pipe(self.loop)
        self.pipe1.bind(TEST_PIPE1)
        self.pipe1.listen(on_connection)

        self.pipe2 = uv.Pipe(self.loop)
        self.pipe2.connect(TEST_PIPE1, callback=on_connect)

        self.loop.run()
コード例 #4
0
    def test_connect_bad(self):
        def on_connect(stream, status):
            self.assert_not_equal(status, uv.error.STATUS_SUCCESS)
            stream.close()

        self.pipe = uv.Pipe(self.loop)
        self.pipe.connect(BAD_PIPE, callback=on_connect)

        self.loop.run()
コード例 #5
0
ファイル: test_stream.py プロジェクト: kasicass/fatuv
 def test_closed(self):
     self.pipe = uv.Pipe(self.loop)
     self.pipe.close()
     self.assert_false(self.pipe.readable)
     self.assert_false(self.pipe.writable)
     self.assert_raises(uv.HandleClosedError, self.pipe.shutdown)
     self.assert_raises(uv.HandleClosedError, self.pipe.listen, None)
     self.assert_raises(uv.HandleClosedError, self.pipe.start_read, None)
     self.assert_is(self.pipe.stop_read(), None)
     self.assert_raises(uv.HandleClosedError, self.pipe.write, b'')
     self.assert_raises(uv.HandleClosedError, self.pipe.try_write, b'')
     self.assert_raises(uv.HandleClosedError, self.pipe.accept, None)
コード例 #6
0
	def test_closed(self):
		self.pipe = uv.Pipe(self.loop)
		self.pipe.close()

		self.assert_raises(uv.error.HandleError, self.pipe.open, 0)
		self.assert_equal(self.pipe.pending_count, 0)
		self.assert_equal(self.pipe.pending_type, None)
		#self.assert_raises(uv.error.HandleClosedError, self.pipe.pending_accept)
		self.assert_raises(uv.error.HandleClosedError, self.pipe.pending_instances, 100)
		#with self.should_raise(uv.error.HandleClosedError):
		#	sockname = self.pipe.sockname
		#with self.should_raise(uv.error.HandleClosedError):
		#	peername = self.pipe.peername
		self.assert_raises(uv.error.HandleClosedError, self.pipe.bind, '')
		self.assert_raises(uv.error.HandleClosedError, self.pipe.connect, '')
コード例 #7
0
 def test_pipe_open(self):
     unix_socket = socket.socket(family=socket.AF_UNIX)
     self.pipe = uv.Pipe(self.loop)
     self.pipe.open(unix_socket.fileno())
     self.assert_equal(self.pipe.fileno(), unix_socket.fileno())
コード例 #8
0
 def test_family(self):
     self.pipe = uv.Pipe(self.loop)
コード例 #9
0
 def test_no_pending_accept(self):
     self.pipe = uv.Pipe(self.loop)
コード例 #10
0
 def test_sockname(self):
     self.pipe = uv.Pipe(self.loop)
     self.pipe.bind(TEST_PIPE1)
コード例 #11
0
ファイル: test_stream.py プロジェクト: kasicass/fatuv
 def test_writable_readable(self):
     self.pipe = uv.Pipe(self.loop)
     self.assert_false(self.pipe.readable)
     self.assert_false(self.pipe.writable)
コード例 #12
0
ファイル: test_stream.py プロジェクト: kasicass/fatuv
 def on_connection(pipe_handle, status):
     client = uv.Pipe(pipe_handle.loop)
     pipe_handle.accept(client)
     client.start_read(on_read)
     pipe_handle.close()