Debian Codegraph @

Lib/test/test_asyncio/test_sendfile.py

raw
1 """Tests for sendfile functionality."""
2
3 import asyncio
4 import errno
5 import os
6 import socket
7 import sys
8 import tempfile
9 import unittest
10 from asyncio import base_events
11 from asyncio import constants
12 from unittest import mock
13 from test import support
14 from test.support import os_helper
15 from test.support import socket_helper
16 from test.test_asyncio import utils as test_utils
17
18 try:
19 import ssl
20 except ImportError:
21 ssl = None
22
23
24 def tearDownModule():
25 asyncio.events._set_event_loop_policy(None)
26
27
28 class MySendfileProto(asyncio.Protocol):
29
30 def __init__(self, loop=None, close_after=0):
31 self.transport = None
32 self.state = 'INITIAL'
33 self.nbytes = 0
34 if loop is not None:
35 self.connected = loop.create_future()
36 self.done = loop.create_future()
37 self.data = bytearray()
38 self.close_after = close_after
39
40 def _assert_state(self, *expected):
41 if self.state not in expected:
42 raise AssertionError(f'state: {self.state!r}, expected: {expected!r}')
43
44 def connection_made(self, transport):
45 self.transport = transport
46 self._assert_state('INITIAL')
47 self.state = 'CONNECTED'
48 if self.connected:
49 self.connected.set_result(None)
50
51 def eof_received(self):
52 self._assert_state('CONNECTED')
53 self.state = 'EOF'
54
55 def connection_lost(self, exc):
56 self._assert_state('CONNECTED', 'EOF')
57 self.state = 'CLOSED'
58 if self.done:
59 self.done.set_result(None)
60
61 def data_received(self, data):
62 self._assert_state('CONNECTED')
63 self.nbytes += len(data)
64 self.data.extend(data)
65 super().data_received(data)
66 if self.close_after and self.nbytes >= self.close_after:
67 self.transport.close()
68
69
70 class MyProto(asyncio.Protocol):
71
72 def __init__(self, loop):
73 self.started = False
74 self.closed = False
75 self.data = bytearray()
76 self.fut = loop.create_future()
77 self.transport = None
78
79 def connection_made(self, transport):
80 self.started = True
81 self.transport = transport
82
83 def data_received(self, data):
84 self.data.extend(data)
85
86 def connection_lost(self, exc):
87 self.closed = True
88 self.fut.set_result(None)
89
90 async def wait_closed(self):
91 await self.fut
92
93
94 class SendfileBase:
95
96 # Linux >= 6.10 seems buffering up to 17 pages of data.
97 # So DATA should be large enough to make this test reliable even with a
98 # 64 KiB page configuration.
99 DATA = b"x" * (1024 * 17 * 64 + 1)
100 # Reduce socket buffer size to test on relative small data sets.
101 BUF_SIZE = 4 * 1024 # 4 KiB
102
103 def create_event_loop(self):
104 raise NotImplementedError
105
106 @classmethod
107 def setUpClass(cls):
108 with open(os_helper.TESTFN, 'wb') as fp:
109 fp.write(cls.DATA)
110 super().setUpClass()
111
112 @classmethod
113 def tearDownClass(cls):
114 os_helper.unlink(os_helper.TESTFN)
115 super().tearDownClass()
116
117 def setUp(self):
118 self.file = open(os_helper.TESTFN, 'rb')
119 self.addCleanup(self.file.close)
120 self.loop = self.create_event_loop()
121 self.set_event_loop(self.loop)
122 super().setUp()
123
124 def tearDown(self):
125 # just in case if we have transport close callbacks
126 if not self.loop.is_closed():
127 test_utils.run_briefly(self.loop)
128
129 self.doCleanups()
130 support.gc_collect()
131 super().tearDown()
132
133 def run_loop(self, coro):
134 return self.loop.run_until_complete(coro)
135
136
137 class SockSendfileMixin(SendfileBase):
138
139 @classmethod
140 def setUpClass(cls):
141 cls.__old_bufsize = constants.SENDFILE_FALLBACK_READBUFFER_SIZE
142 constants.SENDFILE_FALLBACK_READBUFFER_SIZE = 1024 * 16
143 super().setUpClass()
144
145 @classmethod
146 def tearDownClass(cls):
147 constants.SENDFILE_FALLBACK_READBUFFER_SIZE = cls.__old_bufsize
148 super().tearDownClass()
149
150 def make_socket(self, cleanup=True):
151 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
152 sock.setblocking(False)
153 if cleanup:
154 self.addCleanup(sock.close)
155 return sock
156
157 def reduce_receive_buffer_size(self, sock):
158 # Reduce receive socket buffer size to test on relative
159 # small data sets.
160 sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, self.BUF_SIZE)
161
162 def reduce_send_buffer_size(self, sock, transport=None):
163 # Reduce send socket buffer size to test on relative small data sets.
164
165 # On macOS, SO_SNDBUF is reset by connect(). So this method
166 # should be called after the socket is connected.
167 sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, self.BUF_SIZE)
168
169 if transport is not None:
170 transport.set_write_buffer_limits(high=self.BUF_SIZE)
171
172 def prepare_socksendfile(self):
173 proto = MyProto(self.loop)
174 port = socket_helper.find_unused_port()
175 srv_sock = self.make_socket(cleanup=False)
176 srv_sock.bind((socket_helper.HOST, port))
177 server = self.run_loop(self.loop.create_server(
178 lambda: proto, sock=srv_sock))
179 self.reduce_receive_buffer_size(srv_sock)
180
181 sock = self.make_socket()
182 self.run_loop(self.loop.sock_connect(sock, ('127.0.0.1', port)))
183 self.reduce_send_buffer_size(sock)
184
185 def cleanup():
186 if proto.transport is not None:
187 # can be None if the task was cancelled before
188 # connection_made callback
189 proto.transport.close()
190 self.run_loop(proto.wait_closed())
191
192 server.close()
193 self.run_loop(server.wait_closed())
194
195 self.addCleanup(cleanup)
196
197 return sock, proto
198
199 def test_sock_sendfile_success(self):
200 sock, proto = self.prepare_socksendfile()
201 ret = self.run_loop(self.loop.sock_sendfile(sock, self.file))
202 sock.close()
203 self.run_loop(proto.wait_closed())
204
205 self.assertEqual(ret, len(self.DATA))
206 self.assertEqual(proto.data, self.DATA)
207 self.assertEqual(self.file.tell(), len(self.DATA))
208
209 def test_sock_sendfile_with_offset_and_count(self):
210 sock, proto = self.prepare_socksendfile()
211 ret = self.run_loop(self.loop.sock_sendfile(sock, self.file,
212 1000, 2000))
213 sock.close()
214 self.run_loop(proto.wait_closed())
215
216 self.assertEqual(proto.data, self.DATA[1000:3000])
217 self.assertEqual(self.file.tell(), 3000)
218 self.assertEqual(ret, 2000)
219
220 def test_sock_sendfile_zero_size(self):
221 sock, proto = self.prepare_socksendfile()
222 with tempfile.TemporaryFile() as f:
223 ret = self.run_loop(self.loop.sock_sendfile(sock, f,
224 0, None))
225 sock.close()
226 self.run_loop(proto.wait_closed())
227
228 self.assertEqual(ret, 0)
229 self.assertEqual(self.file.tell(), 0)
230
231 def check_sock_sendfile_offset(self, data, offset, force_fallback=False):
232 sock, proto = self.prepare_socksendfile()
233 with tempfile.TemporaryFile() as f:
234 f.write(data)
235 f.flush()
236 self.assertEqual(f.tell(), len(data))
237
238 if force_fallback:
239 async def _sock_sendfile_fail(sock, file, offset, count):
240 raise asyncio.exceptions.SendfileNotAvailableError()
241 with support.swap_attr(self.loop, '_sock_sendfile_native', _sock_sendfile_fail):
242 ret = self.run_loop(self.loop.sock_sendfile(sock, f, offset, None))
243 else:
244 ret = self.run_loop(self.loop.sock_sendfile(sock, f, offset, None))
245
246 self.assertEqual(f.tell(), len(data))
247
248 sock.close()
249 self.run_loop(proto.wait_closed())
250
251 self.assertEqual(ret, len(data) - offset)
252
253
254 def test_sock_sendfile_offset(self):
255 data = b'abcdef'
256 for offset in (0, len(data) // 2, len(data)):
257 for force_fallback in (False, True):
258 with self.subTest(offset=offset, force_fallback=force_fallback):
259 self.check_sock_sendfile_offset(data, offset, force_fallback)
260
261 def check_sendfile_offset(self, offset, fallback):
262 srv_proto, cli_proto = self.prepare_sendfile()
263 self.file.seek(123)
264 coro = self.loop.sendfile(cli_proto.transport, self.file, offset, fallback=fallback)
265 try:
266 ret = self.run_loop(coro)
267 except asyncio.SendfileNotAvailableError:
268 if fallback:
269 raise
270 cli_proto.transport.close()
271 self.run_loop(srv_proto.done)
272 return
273 cli_proto.transport.close()
274 self.run_loop(srv_proto.done)
275 self.assertEqual(ret, len(self.DATA) - offset)
276 self.assertEqual(srv_proto.nbytes, len(self.DATA) - offset)
277 self.assertEqual(srv_proto.data, self.DATA[offset:])
278 self.assertEqual(self.file.tell(), len(self.DATA))
279
280 def test_sendfile_offset(self):
281 for offset in (0, len(self.DATA) // 2, len(self.DATA)):
282 for fallback in (False, True):
283 with self.subTest(offset=offset, fallback=fallback):
284 self.check_sendfile_offset(offset, fallback)
285
286 def test_sock_sendfile_mix_with_regular_send(self):
287 buf = b"mix_regular_send" * (4 * 1024) # 64 KiB
288 sock, proto = self.prepare_socksendfile()
289 self.run_loop(self.loop.sock_sendall(sock, buf))
290 ret = self.run_loop(self.loop.sock_sendfile(sock, self.file))
291 self.run_loop(self.loop.sock_sendall(sock, buf))
292 sock.close()
293 self.run_loop(proto.wait_closed())
294
295 self.assertEqual(ret, len(self.DATA))
296 expected = buf + self.DATA + buf
297 self.assertEqual(proto.data, expected)
298 self.assertEqual(self.file.tell(), len(self.DATA))
299
300
301 class SendfileMixin(SendfileBase):
302
303 # Note: sendfile via SSL transport is equal to sendfile fallback
304
305 def prepare_sendfile(self, *, is_ssl=False, close_after=0):
306 port = socket_helper.find_unused_port()
307 srv_proto = MySendfileProto(loop=self.loop,
308 close_after=close_after)
309 if is_ssl:
310 if not ssl:
311 self.skipTest("No ssl module")
312 srv_ctx = test_utils.simple_server_sslcontext()
313 cli_ctx = test_utils.simple_client_sslcontext()
314 else:
315 srv_ctx = None
316 cli_ctx = None
317 srv_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
318 srv_sock.bind((socket_helper.HOST, port))
319 server = self.run_loop(self.loop.create_server(
320 lambda: srv_proto, sock=srv_sock, ssl=srv_ctx))
321 self.reduce_receive_buffer_size(srv_sock)
322
323 if is_ssl:
324 server_hostname = socket_helper.HOST
325 else:
326 server_hostname = None
327 cli_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
328 cli_sock.connect((socket_helper.HOST, port))
329
330 cli_proto = MySendfileProto(loop=self.loop)
331 tr, pr = self.run_loop(self.loop.create_connection(
332 lambda: cli_proto, sock=cli_sock,
333 ssl=cli_ctx, server_hostname=server_hostname))
334 self.reduce_send_buffer_size(cli_sock, transport=tr)
335
336 def cleanup():
337 srv_proto.transport.close()
338 cli_proto.transport.close()
339 self.run_loop(srv_proto.done)
340 self.run_loop(cli_proto.done)
341
342 server.close()
343 self.run_loop(server.wait_closed())
344
345 self.addCleanup(cleanup)
346 return srv_proto, cli_proto
347
348 @unittest.skipIf(sys.platform == 'win32', "UDP sockets are not supported")
349 def test_sendfile_not_supported(self):
350 tr, pr = self.run_loop(
351 self.loop.create_datagram_endpoint(
352 asyncio.DatagramProtocol,
353 family=socket.AF_INET))
354 try:
355 with self.assertRaisesRegex(RuntimeError, "not supported"):
356 self.run_loop(
357 self.loop.sendfile(tr, self.file))
358 self.assertEqual(0, self.file.tell())
359 finally:
360 # don't use self.addCleanup because it produces resource warning
361 tr.close()
362
363 def test_sendfile(self):
364 srv_proto, cli_proto = self.prepare_sendfile()
365 ret = self.run_loop(
366 self.loop.sendfile(cli_proto.transport, self.file))
367 cli_proto.transport.close()
368 self.run_loop(srv_proto.done)
369 self.assertEqual(ret, len(self.DATA))
370 self.assertEqual(srv_proto.nbytes, len(self.DATA))
371 self.assertEqual(srv_proto.data, self.DATA)
372 self.assertEqual(self.file.tell(), len(self.DATA))
373
374 def test_sendfile_force_fallback(self):
375 srv_proto, cli_proto = self.prepare_sendfile()
376
377 def sendfile_native(transp, file, offset, count):
378 # to raise SendfileNotAvailableError
379 return base_events.BaseEventLoop._sendfile_native(
380 self.loop, transp, file, offset, count)
381
382 self.loop._sendfile_native = sendfile_native
383
384 ret = self.run_loop(
385 self.loop.sendfile(cli_proto.transport, self.file))
386 cli_proto.transport.close()
387 self.run_loop(srv_proto.done)
388 self.assertEqual(ret, len(self.DATA))
389 self.assertEqual(srv_proto.nbytes, len(self.DATA))
390 self.assertEqual(srv_proto.data, self.DATA)
391 self.assertEqual(self.file.tell(), len(self.DATA))
392
393 def test_sendfile_force_unsupported_native(self):
394 if sys.platform == 'win32':
395 if isinstance(self.loop, asyncio.ProactorEventLoop):
396 self.skipTest("Fails on proactor event loop")
397 srv_proto, cli_proto = self.prepare_sendfile()
398
399 def sendfile_native(transp, file, offset, count):
400 # to raise SendfileNotAvailableError
401 return base_events.BaseEventLoop._sendfile_native(
402 self.loop, transp, file, offset, count)
403
404 self.loop._sendfile_native = sendfile_native
405
406 with self.assertRaisesRegex(asyncio.SendfileNotAvailableError,
407 "not supported"):
408 self.run_loop(
409 self.loop.sendfile(cli_proto.transport, self.file,
410 fallback=False))
411
412 cli_proto.transport.close()
413 self.run_loop(srv_proto.done)
414 self.assertEqual(srv_proto.nbytes, 0)
415 self.assertEqual(self.file.tell(), 0)
416
417 def test_sendfile_ssl(self):
418 srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
419 ret = self.run_loop(
420 self.loop.sendfile(cli_proto.transport, self.file))
421 cli_proto.transport.close()
422 self.run_loop(srv_proto.done)
423 self.assertEqual(ret, len(self.DATA))
424 self.assertEqual(srv_proto.nbytes, len(self.DATA))
425 self.assertEqual(srv_proto.data, self.DATA)
426 self.assertEqual(self.file.tell(), len(self.DATA))
427
428 def test_sendfile_for_closing_transp(self):
429 srv_proto, cli_proto = self.prepare_sendfile()
430 cli_proto.transport.close()
431 with self.assertRaisesRegex(RuntimeError, "is closing"):
432 self.run_loop(self.loop.sendfile(cli_proto.transport, self.file))
433 self.run_loop(srv_proto.done)
434 self.assertEqual(srv_proto.nbytes, 0)
435 self.assertEqual(self.file.tell(), 0)
436
437 def test_sendfile_pre_and_post_data(self):
438 srv_proto, cli_proto = self.prepare_sendfile()
439 PREFIX = b'PREFIX__' * 1024 # 8 KiB
440 SUFFIX = b'--SUFFIX' * 1024 # 8 KiB
441 cli_proto.transport.write(PREFIX)
442 ret = self.run_loop(
443 self.loop.sendfile(cli_proto.transport, self.file))
444 cli_proto.transport.write(SUFFIX)
445 cli_proto.transport.close()
446 self.run_loop(srv_proto.done)
447 self.assertEqual(ret, len(self.DATA))
448 self.assertEqual(srv_proto.data, PREFIX + self.DATA + SUFFIX)
449 self.assertEqual(self.file.tell(), len(self.DATA))
450
451 def test_sendfile_ssl_pre_and_post_data(self):
452 srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
453 PREFIX = b'zxcvbnm' * 1024
454 SUFFIX = b'0987654321' * 1024
455 cli_proto.transport.write(PREFIX)
456 ret = self.run_loop(
457 self.loop.sendfile(cli_proto.transport, self.file))
458 cli_proto.transport.write(SUFFIX)
459 cli_proto.transport.close()
460 self.run_loop(srv_proto.done)
461 self.assertEqual(ret, len(self.DATA))
462 self.assertEqual(srv_proto.data, PREFIX + self.DATA + SUFFIX)
463 self.assertEqual(self.file.tell(), len(self.DATA))
464
465 def test_sendfile_partial(self):
466 srv_proto, cli_proto = self.prepare_sendfile()
467 ret = self.run_loop(
468 self.loop.sendfile(cli_proto.transport, self.file, 1000, 100))
469 cli_proto.transport.close()
470 self.run_loop(srv_proto.done)
471 self.assertEqual(ret, 100)
472 self.assertEqual(srv_proto.nbytes, 100)
473 self.assertEqual(srv_proto.data, self.DATA[1000:1100])
474 self.assertEqual(self.file.tell(), 1100)
475
476 def test_sendfile_ssl_partial(self):
477 srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
478 ret = self.run_loop(
479 self.loop.sendfile(cli_proto.transport, self.file, 1000, 100))
480 cli_proto.transport.close()
481 self.run_loop(srv_proto.done)
482 self.assertEqual(ret, 100)
483 self.assertEqual(srv_proto.nbytes, 100)
484 self.assertEqual(srv_proto.data, self.DATA[1000:1100])
485 self.assertEqual(self.file.tell(), 1100)
486
487 def test_sendfile_close_peer_after_receiving(self):
488 srv_proto, cli_proto = self.prepare_sendfile(
489 close_after=len(self.DATA))
490 ret = self.run_loop(
491 self.loop.sendfile(cli_proto.transport, self.file))
492 cli_proto.transport.close()
493 self.run_loop(srv_proto.done)
494 self.assertEqual(ret, len(self.DATA))
495 self.assertEqual(srv_proto.nbytes, len(self.DATA))
496 self.assertEqual(srv_proto.data, self.DATA)
497 self.assertEqual(self.file.tell(), len(self.DATA))
498
499 def test_sendfile_ssl_close_peer_after_receiving(self):
500 srv_proto, cli_proto = self.prepare_sendfile(
501 is_ssl=True, close_after=len(self.DATA))
502 ret = self.run_loop(
503 self.loop.sendfile(cli_proto.transport, self.file))
504 self.run_loop(srv_proto.done)
505 self.assertEqual(ret, len(self.DATA))
506 self.assertEqual(srv_proto.nbytes, len(self.DATA))
507 self.assertEqual(srv_proto.data, self.DATA)
508 self.assertEqual(self.file.tell(), len(self.DATA))
509
510 # On Solaris, lowering SO_RCVBUF on a TCP connection after it has been
511 # established has no effect. Due to its age, this bug affects both Oracle
512 # Solaris as well as all other OpenSolaris forks (unless they fixed it
513 # themselves).
514 @unittest.skipIf(sys.platform.startswith('sunos'),
515 "Doesn't work on Solaris")
516 def test_sendfile_close_peer_in_the_middle_of_receiving(self):
517 srv_proto, cli_proto = self.prepare_sendfile(close_after=1024)
518 with self.assertRaises(ConnectionError):
519 self.run_loop(
520 self.loop.sendfile(cli_proto.transport, self.file))
521 self.run_loop(srv_proto.done)
522
523 self.assertTrue(1024 <= srv_proto.nbytes < len(self.DATA),
524 srv_proto.nbytes)
525 if not (sys.platform == 'win32'
526 and isinstance(self.loop, asyncio.ProactorEventLoop)):
527 # On Windows, Proactor uses transmitFile, which does not update tell()
528 self.assertTrue(1024 <= self.file.tell() < len(self.DATA),
529 self.file.tell())
530 self.assertTrue(cli_proto.transport.is_closing())
531
532 def test_sendfile_fallback_close_peer_in_the_middle_of_receiving(self):
533
534 def sendfile_native(transp, file, offset, count):
535 # to raise SendfileNotAvailableError
536 return base_events.BaseEventLoop._sendfile_native(
537 self.loop, transp, file, offset, count)
538
539 self.loop._sendfile_native = sendfile_native
540
541 srv_proto, cli_proto = self.prepare_sendfile(close_after=1024)
542 with self.assertRaises(ConnectionError):
543 try:
544 self.run_loop(
545 self.loop.sendfile(cli_proto.transport, self.file))
546 except OSError as e:
547 # macOS may raise OSError of EPROTOTYPE when writing to a
548 # socket that is in the process of closing down.
549 if e.errno == errno.EPROTOTYPE and sys.platform == "darwin":
550 raise ConnectionError
551 else:
552 raise
553
554 self.run_loop(srv_proto.done)
555
556 self.assertTrue(1024 <= srv_proto.nbytes < len(self.DATA),
557 srv_proto.nbytes)
558 self.assertTrue(1024 <= self.file.tell() < len(self.DATA),
559 self.file.tell())
560
561 @unittest.skipIf(not hasattr(os, 'sendfile'),
562 "Don't have native sendfile support")
563 def test_sendfile_prevents_bare_write(self):
564 srv_proto, cli_proto = self.prepare_sendfile()
565 fut = self.loop.create_future()
566
567 async def coro():
568 fut.set_result(None)
569 return await self.loop.sendfile(cli_proto.transport, self.file)
570
571 t = self.loop.create_task(coro())
572 self.run_loop(fut)
573 with self.assertRaisesRegex(RuntimeError,
574 "sendfile is in progress"):
575 cli_proto.transport.write(b'data')
576 ret = self.run_loop(t)
577 self.assertEqual(ret, len(self.DATA))
578
579 def test_sendfile_no_fallback_for_fallback_transport(self):
580 transport = mock.Mock()
581 transport.is_closing.side_effect = lambda: False
582 transport._sendfile_compatible = constants._SendfileMode.FALLBACK
583 with self.assertRaisesRegex(RuntimeError, 'fallback is disabled'):
584 self.loop.run_until_complete(
585 self.loop.sendfile(transport, None, fallback=False))
586
587
588 class SendfileTestsBase(SendfileMixin, SockSendfileMixin):
589 pass
590
591
592 if sys.platform == 'win32':
593
594 class SelectEventLoopTests(SendfileTestsBase,
595 test_utils.TestCase):
596
597 def create_event_loop(self):
598 return asyncio.SelectorEventLoop()
599
600 class ProactorEventLoopTests(SendfileTestsBase,
601 test_utils.TestCase):
602
603 def create_event_loop(self):
604 return asyncio.ProactorEventLoop()
605
606 else:
607 import selectors
608
609 if hasattr(selectors, 'KqueueSelector'):
610 class KqueueEventLoopTests(SendfileTestsBase,
611 test_utils.TestCase):
612
613 def create_event_loop(self):
614 return asyncio.SelectorEventLoop(
615 selectors.KqueueSelector())
616
617 if hasattr(selectors, 'EpollSelector'):
618 class EPollEventLoopTests(SendfileTestsBase,
619 test_utils.TestCase):
620
621 def create_event_loop(self):
622 return asyncio.SelectorEventLoop(selectors.EpollSelector())
623
624 if hasattr(selectors, 'PollSelector'):
625 class PollEventLoopTests(SendfileTestsBase,
626 test_utils.TestCase):
627
628 def create_event_loop(self):
629 return asyncio.SelectorEventLoop(selectors.PollSelector())
630
631 # Should always exist.
632 class SelectEventLoopTests(SendfileTestsBase,
633 test_utils.TestCase):
634
635 def create_event_loop(self):
636 return asyncio.SelectorEventLoop(selectors.SelectSelector())
637
638
639 if __name__ == '__main__':
640 unittest.main()